def __init__(self):
self.ticks=0
base.setBackgroundColor(224.0/255.0, 188.0/255.0, 112.0/255.0)
base.camera.setPos(100,100,100)
self.correctAspectRatio()
self.titleScreenTrack=loader.loadModel("models/titlescreentrack")
self.titleScreenTrack.setScale(1.0)
self.titleScreenTrack.reparentTo(render)
self.titleScreenTrack.setPos(0.0,-10,-2.5)
self.trackRotation=0
self.titleScreenTitle=loader.loadModel("models/gridleader")
self.titleScreenTitle.setScale(1.0)
self.titleScreenTitle.setH(180.0)
self.titleScreenTitle.reparentTo(render)
self.titleScreenTitle.setPos(0.0,-10,0.3)
self.titleScreenText=TitleScreenText()
startLineCm=CardMaker('card')
# left, right, top, bottom
startLineCm.setFrame(0,2.25,0,0.6)
startLineNode=self.titleScreenTrack.attachNewNode(startLineCm.generate())
startLineNode.setTwoSided(True)
startLineNode.setBillboardAxis()
startLineNode.setTransparency(TransparencyAttrib.MAlpha)
tex=loader.loadTexture('textures/titlestartline.png')
tex.setWrapU(Texture.WMClamp)
tex.setWrapV(Texture.WMClamp)
startLineNode.setTexture(tex)
startLineNode.setPos(-0.202,1.521,0)
self.startLineNode=startLineNode
base.accept('aspectRatioChanged',self.correctAspectRatio)
def setupRightTexture(self):
cm = CardMaker('quadMaker')
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT) / float(WIN_HEIGHT)
# the html area will be center aligned and vertically top aligned
#cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0)
cm.setFrame(0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0)
card = cm.generate()
self.rightQuad = NodePath(card)
self.rightQuad.reparentTo(self.parent)
self.rightGuiTex = Texture("guiTex")
self.rightGuiTex.setupTexture(Texture.TT2dTexture, WEB_HALF_WIDTH,
WEB_HEIGHT, 1, Texture.TUnsignedByte,
Texture.FRgba)
self.rightGuiTex.setKeepRamImage(True)
self.rightGuiTex.makeRamImage()
self.rightGuiTex.setWrapU(Texture.WMClamp)
self.rightGuiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('rightWebTS')
self.rightQuad.setTexture(ts, self.rightGuiTex)
self.rightQuad.setTexScale(ts, 1.0, -1.0)
self.rightQuad.setTransparency(0)
self.rightQuad.setTwoSided(True)
self.rightQuad.setColor(1.0, 1.0, 1.0, 1.0)
def _initModel(self):
baseName = '**/tt_t_gui_cmg_miniMap_'
cardModel = CogdoUtil.loadMazeModel('miniMap_cards', group='gui')
cm = CardMaker('bg')
cm.setFrame(-1.1, 1.1, -1.1, 1.1)
bg = self.attachNewNode(cm.generate())
bg.setColor(*self._bgColor)
bg.setBin('fixed', 0)
frame = cardModel.find(baseName + 'frame')
frame.reparentTo(self)
frame.setScale(2.5)
frame.setPos(0.01, 0, -0.01)
self._entrance = cardModel.find(baseName + 'entrance')
self._entrance.reparentTo(self)
self._entrance.setScale(0.35)
self._entrance.hide()
self._exit = NodePath('exit')
self._exit.setScale(0.35)
self._exit.reparentTo(self)
self._exitOpen = cardModel.find(baseName + 'exitOpen')
self._exitOpen.reparentTo(self._exit)
self._exitClosed = cardModel.find(baseName + 'exitClosed')
self._exitClosed.reparentTo(self._exit)
self._suitMarkerTemplate = cardModel.find(baseName + 'cogIcon')
self._suitMarkerTemplate.detachNode()
self._suitMarkerTemplate.setScale(0.225)
self._waterCoolerTemplate = cardModel.find(baseName + 'waterDrop')
self._waterCoolerTemplate.detachNode()
self._waterCoolerTemplate.setScale(0.225)
self._exit.hide()
cardModel.removeNode()
def __init__(self, av, **kw):
DirectFrame.__init__(self, relief=None, sortOrder=50)
self.initialiseoptions(QuestMap)
self.container = DirectFrame(parent=self, relief=None)
self.marker = DirectFrame(parent=self.container, relief=None)
self.cogInfoFrame = DirectFrame(parent=self.container, relief=None)
cm = CardMaker('bg')
cm.setFrame(-0.5, 0.5, -0.5, 0.5)
bg = self.cogInfoFrame.attachNewNode(cm.generate())
bg.setTransparency(1)
bg.setColor(0.5, 0.5, 0.5, 0.5)
bg.setBin('fixed', 0)
self.cogInfoFrame['geom'] = bg
self.cogInfoFrame['geom_pos'] = (0, 0, 0)
self.cogInfoFrame['geom_scale'] = (6, 1, 2)
self.cogInfoFrame.setScale(0.05)
self.cogInfoFrame.setPos(0, 0, 0.6)
self.buildingMarkers = []
self.av = av
self.wantToggle = base.config.GetBool('want-toggle-quest-map', True)
self.updateMarker = True
self.cornerPosInfo = None
self.hqPosInfo = None
self.fishingSpotInfo = None
self.load()
self.setScale(1.5)
bg.removeNode()
self.hoodId = None
self.zoneId = None
self.suitPercentage = {}
for currHoodInfo in SuitPlannerBase.SuitPlannerBase.SuitHoodInfo:
tracks = currHoodInfo[SuitPlannerBase.SuitPlannerBase.SUIT_HOOD_INFO_TRACK]
self.suitPercentage[currHoodInfo[SuitPlannerBase.SuitPlannerBase.SUIT_HOOD_INFO_ZONE]] = tracks
return
def setupTexture(self):
cm = CardMaker('quadMaker')
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT)
cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0)
bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1)
bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1)
cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1))
card = cm.generate()
self.quad = NodePath(card)
self.quad.reparentTo(self.parent)
self.guiTex = Texture('guiTex')
self.guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba)
self.guiTex.setMinfilter(Texture.FTLinear)
self.guiTex.setKeepRamImage(True)
self.guiTex.makeRamImage()
self.guiTex.setWrapU(Texture.WMRepeat)
self.guiTex.setWrapV(Texture.WMRepeat)
ts = TextureStage('webTS')
self.quad.setTexture(ts, self.guiTex)
self.quad.setTexScale(ts, 1.0, -1.0)
self.quad.setTransparency(0)
self.quad.setTwoSided(True)
self.quad.setColor(1.0, 1.0, 1.0, 1.0)
self.calcMouseLimits()
def _createMapTextureCard(self):
mapImage = PNMImage(MAP_RESOLUTION, MAP_RESOLUTION)
mapImage.fill(*self._bgColor)
fgColor = VBase4D(*self._fgColor)
for x in xrange(self._mazeHeight):
for y in xrange(self._mazeWidth):
if self._mazeCollTable[y][x] == 1:
ax = float(x) / self._mazeWidth * MAP_RESOLUTION
invertedY = self._mazeHeight - 1 - y
ay = float(invertedY) / self._mazeHeight * MAP_RESOLUTION
self._drawSquare(mapImage, int(ax), int(ay), 10, fgColor)
mapTexture = Texture('mapTexture')
mapTexture.setupTexture(Texture.TT2dTexture, self._maskResolution, self._maskResolution, 1, Texture.TUnsignedByte, Texture.FRgba)
mapTexture.setMinfilter(Texture.FTLinear)
mapTexture.load(mapImage)
mapTexture.setWrapU(Texture.WMClamp)
mapTexture.setWrapV(Texture.WMClamp)
mapImage.clear()
del mapImage
cm = CardMaker('map_cardMaker')
cm.setFrame(-1.0, 1.0, -1.0, 1.0)
map = self.attachNewNode(cm.generate())
map.setTexture(mapTexture, 1)
return map
def __init__( self, *args, **kwargs ):
colour = kwargs.pop( 'colour', (1, 1, 1, .2) )
p3d.SingleTask.__init__( self, *args, **kwargs )
# Create a card maker
cm = CardMaker( self.name )
cm.setFrame( 0, 1, 0, 1 )
# Init the node path, wrapping the card maker to make a rectangle
NodePath.__init__( self, cm.generate() )
self.setColor( colour )
self.setTransparency( 1 )
self.reparentTo( self.root2d )
self.hide()
# Create the rectangle border
ls = LineSegs()
ls.moveTo( 0, 0, 0 )
ls.drawTo( 1, 0, 0 )
ls.drawTo( 1, 0, 1 )
ls.drawTo( 0, 0, 1 )
ls.drawTo( 0, 0, 0 )
# Attach border to rectangle
self.attachNewNode( ls.create() )
def genArrow(self, pos, hpr, id):
factory = CardMaker('factory')
factory.setFrame(-0.5, 0.5, -0.5, 0.5)
arrowNode = factory.generate()
arrowRoot = NodePath('root')
baseArrow = NodePath(arrowNode)
baseArrow.setTransparency(1)
baseArrow.setTexture(self.boostArrowTexture)
baseArrow.reparentTo(arrowRoot)
arrow2 = baseArrow.copyTo(baseArrow)
arrow2.setPos(0, 0, 1)
arrow3 = arrow2.copyTo(arrow2)
arrowRoot.setPos(*pos)
arrowRoot.setHpr(*hpr)
baseArrow.setHpr(0, -90, 0)
baseArrow.setScale(24)
arrowRoot.reparentTo(self.geom)
trigger = 'boostArrow' + str(id)
cs = CollisionTube(Point3(0.6, -6, 0), Point3(0.6, 54, 0), 4.8)
cs.setTangible(0)
triggerEvent = 'imIn-' + trigger
cn = CollisionNode(trigger)
cn.addSolid(cs)
cn.setIntoCollideMask(BitMask32(32768))
cn.setFromCollideMask(BitMask32(32768))
cnp = NodePath(cn)
cnp.reparentTo(arrowRoot)
self.accept(triggerEvent, self.hitBoostArrow)
arrowVec = arrow2.getPos(self.geom) - baseArrow.getPos(self.geom)
arrowVec.normalize()
idStr = str(id)
cnp.setTag('boostId', idStr)
self.boostDir[idStr] = arrowVec
base.arrows.append(arrowRoot)
def loadFlatQuad(self, fullFilename):
cm = CardMaker("cm-%s" % fullFilename)
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT)
cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0)
bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1)
bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1)
cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1))
card = cm.generate()
quad = NodePath(card)
jpgFile = PNMImage(WEB_WIDTH, WEB_HEIGHT)
smallerJpgFile = PNMImage()
readFile = smallerJpgFile.read(Filename(fullFilename))
if readFile:
jpgFile.copySubImage(smallerJpgFile, 0, 0)
guiTex = Texture("guiTex")
guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba)
guiTex.setMinfilter(Texture.FTLinear)
guiTex.load(jpgFile)
guiTex.setWrapU(Texture.WMClamp)
guiTex.setWrapV(Texture.WMClamp)
ts = TextureStage("webTS")
quad.setTexture(ts, guiTex)
quad.setTransparency(0)
quad.setTwoSided(True)
quad.setColor(1.0, 1.0, 1.0, 1.0)
result = quad
else:
result = None
Texture.setTexturesPower2(1)
return result
def _initModel(self):
baseName = '**/tt_t_gui_cmg_miniMap_'
cardModel = CogdoUtil.loadMazeModel('miniMap_cards', group='gui')
cm = CardMaker('bg')
cm.setFrame(-1.1, 1.1, -1.1, 1.1)
bg = self.attachNewNode(cm.generate())
bg.setColor(*self._bgColor)
bg.setBin('fixed', 0)
frame = cardModel.find(baseName + 'frame')
frame.reparentTo(self)
frame.setScale(2.5)
frame.setPos(0.01, 0, -0.01)
self._entrance = cardModel.find(baseName + 'entrance')
self._entrance.reparentTo(self)
self._entrance.setScale(0.35)
self._entrance.hide()
self._exit = NodePath('exit')
self._exit.setScale(0.35)
self._exit.reparentTo(self)
self._exitOpen = cardModel.find(baseName + 'exitOpen')
self._exitOpen.reparentTo(self._exit)
self._exitClosed = cardModel.find(baseName + 'exitClosed')
self._exitClosed.reparentTo(self._exit)
self._suitMarkerTemplate = cardModel.find(baseName + 'cogIcon')
self._suitMarkerTemplate.detachNode()
self._suitMarkerTemplate.setScale(0.225)
self._waterCoolerTemplate = cardModel.find(baseName + 'waterDrop')
self._waterCoolerTemplate.detachNode()
self._waterCoolerTemplate.setScale(0.225)
self._exit.hide()
cardModel.removeNode()
def _createMaskTextureCard(self):
"""
This will return a NodePath with a card textured with the map mask. It
also creates several other members that re needed to change the mask.
"""
# create and fill empty mask image
self._maskImage = PNMImage(self._maskResolution, self._maskResolution, 4)
for x in range(self._maskResolution):
for y in range(self._maskResolution):
#maskImage.setXel(x,y,mapImage.getRed(x/13,y/10),mapImage.getGreen(x/13,y/10),mapImage.getBlue(x/13,y/10))
self._maskImage.setXelA(x,y,0,0,0,1)
# create the texture for the mask
self.maskTexture = Texture("maskTexture")
self.maskTexture.setupTexture(Texture.TT2dTexture, self._maskResolution, self._maskResolution, 1, Texture.TUnsignedByte, Texture.FRgba)
self.maskTexture.setMinfilter(Texture.FTLinear)
self.maskTexture.setWrapU(Texture.WMClamp)
self.maskTexture.setWrapV(Texture.WMClamp)
self.maskTexture.load(self._maskImage)
base.graphicsEngine.renderFrame()
# put the mask texture on a card and return it
cm = CardMaker("mask_cardMaker")
cm.setFrame(-1.0,1.0,-1.0,1.0)
mask = self.attachNewNode(cm.generate())
mask.setTexture(self.maskTexture, 1)
mask.setTransparency(1)
return mask
def loadFlatQuad(self, fullFilename):
cm = CardMaker('cm-%s' % fullFilename)
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT)
cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0,
htmlHeight / 2.0)
bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1)
bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1)
cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1))
card = cm.generate()
quad = NodePath(card)
jpgFile = PNMImage(WEB_WIDTH, WEB_HEIGHT)
smallerJpgFile = PNMImage()
readFile = smallerJpgFile.read(Filename(fullFilename))
if readFile:
jpgFile.copySubImage(smallerJpgFile, 0, 0)
guiTex = Texture('guiTex')
guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1,
Texture.TUnsignedByte, Texture.FRgba)
guiTex.setMinfilter(Texture.FTLinear)
guiTex.load(jpgFile)
guiTex.setWrapU(Texture.WMClamp)
guiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('webTS')
quad.setTexture(ts, guiTex)
quad.setTransparency(0)
quad.setTwoSided(True)
quad.setColor(1.0, 1.0, 1.0, 1.0)
result = quad
else:
result = None
Texture.setTexturesPower2(1)
return result
def __init__(self, name, nrplates, width, height, shaderfile, texturefile, uvlist, jitter=-1):
self.name = name
self.texturefile = texturefile
self.shaderfile = shaderfile
self.np = NodePath('leaf')
self.tex = loader.loadTexture('textures/' + texturefile)
self.tex.setMinfilter(Texture.FTLinearMipmapLinear)
self.tex.setMagfilter(Texture.FTLinearMipmapLinear)
self.tex.setAnisotropDegree(2)
self.np.setTexture(self.tex)
self.np.setTwoSided(True)
self.np.setTransparency(TransparencyAttrib.MAlpha)
self.np.setDepthWrite(False)
maker = CardMaker('leaf')
maker.setFrame(-width/2.0, width/2.0, 0, height)
#maker.setFrame(0,1,0,1)
for i in range(nrplates):
if uvlist != None:
maker.setUvRange(uvlist[i][0], uvlist[i][1])
else:
maker.setUvRange(Point2(0,0), Point2(1,0.98))
node = self.np.attachNewNode(maker.generate())
#node.setTwoSided(True)
node.setHpr(i * 180.0 / nrplates,0,0)
self.np.flattenStrong()
#np.flattenLight()
#np.setTwoSided(True)
if jitter == -1:
self.jitter = height/width/2
else:
self.jitter = jitter
def setupTexture(self):
cm = CardMaker('quadMaker')
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH)
htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT)
cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0,
htmlHeight / 2.0)
bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1)
bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1)
cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1))
card = cm.generate()
self.quad = NodePath(card)
self.quad.reparentTo(self.parent)
self.guiTex = Texture('guiTex')
self.guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1,
Texture.TUnsignedByte, Texture.FRgba)
self.guiTex.setMinfilter(Texture.FTLinear)
self.guiTex.setKeepRamImage(True)
self.guiTex.makeRamImage()
self.guiTex.setWrapU(Texture.WMRepeat)
self.guiTex.setWrapV(Texture.WMRepeat)
ts = TextureStage('webTS')
self.quad.setTexture(ts, self.guiTex)
self.quad.setTexScale(ts, 1.0, -1.0)
self.quad.setTransparency(0)
self.quad.setTwoSided(True)
self.quad.setColor(1.0, 1.0, 1.0, 1.0)
self.calcMouseLimits()
def _createMapTextureCard(self):
mapImage = PNMImage(MAP_RESOLUTION, MAP_RESOLUTION)
mapImage.fill(*self._bgColor)
fgColor = VBase4D(*self._fgColor)
for x in range(self._mazeHeight):
for y in range(self._mazeWidth):
if self._mazeCollTable[y][x] == 1:
ax = float(x) / self._mazeWidth * MAP_RESOLUTION
invertedY = self._mazeHeight - 1 - y
ay = float(invertedY) / self._mazeHeight * MAP_RESOLUTION
self._drawSquare(mapImage, int(ax), int(ay), 10, fgColor)
mapTexture = Texture('mapTexture')
mapTexture.setupTexture(Texture.TT2dTexture, self._maskResolution,
self._maskResolution, 1, Texture.TUnsignedByte,
Texture.FRgba)
mapTexture.setMinfilter(Texture.FTLinear)
mapTexture.load(mapImage)
mapTexture.setWrapU(Texture.WMClamp)
mapTexture.setWrapV(Texture.WMClamp)
mapImage.clear()
del mapImage
cm = CardMaker('map_cardMaker')
cm.setFrame(-1.0, 1.0, -1.0, 1.0)
map = self.attachNewNode(cm.generate())
map.setTexture(mapTexture, 1)
return map
def __init__(self, av, **kw):
DirectFrame.__init__(self, relief=None, sortOrder=50)
self.initialiseoptions(QuestMap)
self.container = DirectFrame(parent=self, relief=None)
self.marker = DirectFrame(parent=self.container, relief=None)
self.cogInfoFrame = DirectFrame(parent=self.container, relief=None)
cm = CardMaker('bg')
cm.setFrame(-0.5, 0.5, -0.5, 0.5)
bg = self.cogInfoFrame.attachNewNode(cm.generate())
bg.setTransparency(1)
bg.setColor(0.5, 0.5, 0.5, 0.5)
bg.setBin('fixed', 0)
self.cogInfoFrame['geom'] = bg
self.cogInfoFrame['geom_pos'] = (0, 0, 0)
self.cogInfoFrame['geom_scale'] = (6, 1, 2)
self.cogInfoFrame.setScale(0.05)
self.cogInfoFrame.setPos(0, 0, 0.6)
self.buildingMarkers = []
self.av = av
self.updateMarker = True
self.cornerPosInfo = None
self.hqPosInfo = None
self.fishingSpotInfo = None
self.load()
self.setScale(1.5)
bg.removeNode()
self.hoodId = None
self.zoneId = None
self.suitPercentage = {}
for currHoodInfo in SuitPlannerBase.SuitPlannerBase.SuitHoodInfo:
tracks = currHoodInfo[
SuitPlannerBase.SuitPlannerBase.SUIT_HOOD_INFO_TRACK]
self.suitPercentage[currHoodInfo[
SuitPlannerBase.SuitPlannerBase.SUIT_HOOD_INFO_ZONE]] = tracks
def _createSimpleMarker(self, size, color=(1, 1, 1)):
halfSize = size * 0.5
cm = CardMaker('mazemap_simple_marker')
cm.setFrame(-halfSize, halfSize, -halfSize, halfSize)
markerNP = self.maskedLayer.attachNewNode(cm.generate())
markerNP.setColor(*color)
return markerNP
def genArrow(self, pos, hpr, id):
factory = CardMaker('factory')
factory.setFrame(-.5, 0.5, -.5, 0.5)
arrowNode = factory.generate()
arrowRoot = NodePath('root')
baseArrow = NodePath(arrowNode)
baseArrow.setTransparency(1)
baseArrow.setTexture(self.boostArrowTexture)
baseArrow.reparentTo(arrowRoot)
arrow2 = baseArrow.copyTo(baseArrow)
arrow2.setPos(0, 0, 1)
arrow3 = arrow2.copyTo(arrow2)
arrowRoot.setPos(*pos)
arrowRoot.setHpr(*hpr)
baseArrow.setHpr(0, -90, 0)
baseArrow.setScale(24)
arrowRoot.reparentTo(self.geom)
trigger = 'boostArrow' + str(id)
cs = CollisionTube(Point3(0.6, -6, 0), Point3(0.6, 54, 0), 4.8)
cs.setTangible(0)
triggerEvent = 'imIn-' + trigger
cn = CollisionNode(trigger)
cn.addSolid(cs)
cn.setIntoCollideMask(BitMask32(32768))
cn.setFromCollideMask(BitMask32(32768))
cnp = NodePath(cn)
cnp.reparentTo(arrowRoot)
self.accept(triggerEvent, self.hitBoostArrow)
arrowVec = arrow2.getPos(self.geom) - baseArrow.getPos(self.geom)
arrowVec.normalize()
idStr = str(id)
cnp.setTag('boostId', idStr)
self.boostDir[idStr] = arrowVec
base.arrows.append(arrowRoot)
def _createSimpleMarker(self, size, color = (1, 1, 1)):
halfSize = size * 0.5
cm = CardMaker('mazemap_simple_marker')
cm.setFrame(-halfSize, halfSize, -halfSize, halfSize)
markerNP = self.maskedLayer.attachNewNode(cm.generate())
markerNP.setColor(*color)
return markerNP
def __init__(self, name, inclination, baseDimension):
#public props
self.baseDimension = baseDimension
tex = loader.loadTexture(resourceManager.getResource(name) + '.png')
xscaled = tex.getOrigFileXSize() / self.baseDimension
yscaled = tex.getOrigFileYSize() / self.baseDimension
cm = CardMaker("unscrollobject")
cm.setFrame(0, xscaled, 0, yscaled)
ts = TextureStage('ts')
ts.setMode(TextureStage.MDecal)
uvscroll = UvScrollNode("uvscrollnode", 1, 0.0, 0.0, 0.0)
uvscroll.addChild(cm.generate())
self.node = NodePath(uvscroll)
self.node.setTwoSided(True)
self.node.setX((-xscaled / 2) + 0.5)
self.node.setP(-(360 - int(inclination)))
self.node.setTexture(tex)
self.node.setTransparency(TransparencyAttrib.MAlpha)
self.node.reparentTo(render)
def __init__(self, player):
self.player = player
self.root = NodePath("CogdoFlyingGui")
self.root.reparentTo(aspect2d)
self.fuelMeter = NodePath("scrubMeter")
self.fuelMeter.reparentTo(self.root)
self.fuelMeter.setPos(1.1, 0.0, -0.7)
self.fuelMeter.setSz(2.0)
cm = CardMaker('card')
cm.setFrame(-0.07, 0.07, 0.0, 0.75)
self.fuelMeterBar = self.fuelMeter.attachNewNode(cm.generate())
self.fuelMeterBar.setColor(0.95, 0.95, 0.0, 1.0)
self.fuelLabel = DirectLabel(
parent=self.root,
relief=None,
pos=(1.1, 0, -0.8),
scale=0.075,
text="Fuel",
text_fg=(0.95, 0.95, 0, 1),
text_shadow=(0, 0, 0, 1),
text_font=ToontownGlobals.getInterfaceFont(),
)
self.messageLabel = DirectLabel(
parent=self.root,
relief=None,
pos=(0.0, 0.0, -0.9),
scale=0.1,
text=" ",
text_align=TextNode.ACenter,
text_fg=(0.95, 0.95, 0, 1),
text_shadow=(0, 0, 0, 1),
text_font=ToontownGlobals.getInterfaceFont(),
textMayChange=1,
)
self.messageLabel.stash()
self.winLabel = DirectLabel(
parent=self.root,
relief=None,
pos=(0.0, 0.0, 0.0),
scale=0.25,
text="You win!",
text_align=TextNode.ACenter,
text_fg=(0.95, 0.95, 0, 1),
text_shadow=(0, 0, 0, 1),
text_font=ToontownGlobals.getInterfaceFont(),
)
self.winLabel.stash()
self.refuelLerp = LerpFunctionInterval(self.fuelMeterBar.setSz,
fromData=0.0,
toData=1.0,
duration=2.0)
def __init__(self,table=None,mask=None):
"""
@keyword table: filename of a table texture. See table_template.psd. Either
paint anywhere inside the mask for a complete background
or turn off the pads and spinner and paint in the table circle
for just a table texture that will have spinners and pads
put on top of it.
@type mask: str
@keyword mask: filename of a mask texture of the non-Jam-o-Drum area. probably
jod_mask.png that comes with the Jam-o-Drum library.
@type mask: str
"""
NodePath.__init__(self,"JamoDrum")
totalHeight = max(1.0,math.sqrt(2)/4.0+SPINNER_RADIUS)*2
cm = CardMaker("card")
cm.setFrame(-1,1,-1,1)
self.tableCard = self.attachNewNode(cm.generate())
self.tableCard.setP(-90)
self.tableCard.setScale(4.0/3.0)
self.tableCard.setLightOff()
self.tableCard.setBin("background",0)
self.tableCard.setDepthTest(0)
self.tableCard.setDepthWrite(0)
self.tableCard.hide()
if (table):
self.setTableTexture(loader.loadTexture(table))
if (mask):
cm = CardMaker("JOD Mask")
cm.setFrame(-4.0/3.0,4.0/3.0,-4.0/3.0,4.0/3.0)
self.mask = aspect2d.attachNewNode(cm.generate())
#self.mask.setP(-90)
self.mask.setTexture(loader.loadTexture(mask),1)
self.mask.setTransparency(1)
self.mask.setDepthTest(0)
else:
self.mask = None
self.stations = []
for i in range(4):
station = Station(self,i)
station.reparentTo(self)
self.stations.append(station)
self.reparentTo(render)
base.disableMouse()
self.lens = OrthographicLens()
self.lens.setFilmSize(totalHeight*base.getAspectRatio(),totalHeight)
base.cam.node().setLens(self.lens)
camera.setPosHpr(0,0,10.0, 0,-90,0)
base.setBackgroundColor(0,0,0)
self.audio3d = Audio3DManager(base.sfxManagerList[0],self)
self.audio3d.setDropOffFactor(0)
def __init__(self, table=None, mask=None):
"""
@keyword table: filename of a table texture. See table_template.psd. Either
paint anywhere inside the mask for a complete background
or turn off the pads and spinner and paint in the table circle
for just a table texture that will have spinners and pads
put on top of it.
@type mask: str
@keyword mask: filename of a mask texture of the non-Jam-o-Drum area. probably
jod_mask.png that comes with the Jam-o-Drum library.
@type mask: str
"""
NodePath.__init__(self, "JamoDrum")
totalHeight = max(1.0, math.sqrt(2) / 4.0 + SPINNER_RADIUS) * 2
cm = CardMaker("card")
cm.setFrame(-1, 1, -1, 1)
self.tableCard = self.attachNewNode(cm.generate())
self.tableCard.setP(-90)
self.tableCard.setScale(4.0 / 3.0)
self.tableCard.setLightOff()
self.tableCard.setBin("background", 0)
self.tableCard.setDepthTest(0)
self.tableCard.setDepthWrite(0)
self.tableCard.hide()
if (table):
self.setTableTexture(loader.loadTexture(table))
if (mask):
cm = CardMaker("JOD Mask")
cm.setFrame(-4.0 / 3.0, 4.0 / 3.0, -4.0 / 3.0, 4.0 / 3.0)
self.mask = aspect2d.attachNewNode(cm.generate())
#self.mask.setP(-90)
self.mask.setTexture(loader.loadTexture(mask), 1)
self.mask.setTransparency(1)
self.mask.setDepthTest(0)
else:
self.mask = None
self.stations = []
for i in range(4):
station = Station(self, i)
station.reparentTo(self)
self.stations.append(station)
self.reparentTo(render)
base.disableMouse()
self.lens = OrthographicLens()
self.lens.setFilmSize(totalHeight * base.getAspectRatio(), totalHeight)
base.cam.node().setLens(self.lens)
camera.setPosHpr(0, 0, 10.0, 0, -90, 0)
base.setBackgroundColor(0, 0, 0)
self.audio3d = Audio3DManager(base.sfxManagerList[0], self)
self.audio3d.setDropOffFactor(0)
def loadFlatQuad(self, fullFilename):
"""Load the flat jpg into a quad."""
assert self.notify.debugStateCall(self)
#Texture.setTexturesPower2(AutoTextureScale.ATSUp)
#Texture.setTexturesPower2(2)
cm = CardMaker('cm-%s'%fullFilename)
cm.setColor(1.0, 1.0, 1.0, 1.0)
aspect = base.camLens.getAspectRatio()
htmlWidth = 2.0*aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH)
htmlHeight = 2.0*float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT)
# the html area will be center aligned and vertically top aligned
#cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0)
cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, - htmlHeight / 2.0, htmlHeight / 2.0)
bottomRightX = (WEB_WIDTH_PIXELS) / float( WEB_WIDTH +1)
bottomRightY = WEB_HEIGHT_PIXELS / float (WEB_HEIGHT+1)
#cm.setUvRange(Point2(0,0), Point2(bottomRightX, bottomRightY))
cm.setUvRange(Point2(0,1-bottomRightY), Point2(bottomRightX,1))
card = cm.generate()
quad = NodePath(card)
#quad.reparentTo(self.parent)
jpgFile = PNMImage(WEB_WIDTH, WEB_HEIGHT)
smallerJpgFile = PNMImage()
readFile = smallerJpgFile.read(Filename(fullFilename))
if readFile:
jpgFile.copySubImage(smallerJpgFile, 0, 0)
guiTex = Texture("guiTex")
guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba)
guiTex.setMinfilter(Texture.FTLinear)
guiTex.load(jpgFile)
#guiTex.setKeepRamImage(True)
#guiTex.makeRamImage()
guiTex.setWrapU(Texture.WMClamp)
guiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('webTS')
quad.setTexture(ts, guiTex)
#quad.setTexScale(ts, 1.0, -1.0)
quad.setTransparency(0)
quad.setTwoSided(True)
quad.setColor(1.0, 1.0, 1.0, 1.0)
result= quad
else:
# if we have an error loading the file, return None to signify an error
result = None
#Texture.setTexturesPower2(AutoTextureScale.ATSDown)
Texture.setTexturesPower2(1)
return result
def _initGUI(self):
base.loadingScreen.beginStep('init Gui', 4, 55)
cm = CardMaker('PotionBackground')
cm.setFrame(-10, 10, -10, 10)
cm.setColor(0, 0, 0, 1)
self.background = NodePath(cm.generate())
self.background.reparentTo(aspect2d)
self.background.setBin('background', -100)
self.xpBackground = NodePath('PotionXPBackground')
self.xpBackground.reparentTo(aspect2d)
self.xpBackground.setBin('background', -95)
base.loadingScreen.tick()
self.dialogs = NodePath('DialogBackground')
self.dialogs.reparentTo(aspect2d)
self.dialogs.setBin('background', -70)
self.buttonsBackground = NodePath('PotionButtonBackground')
self.buttonsBackground.reparentTo(base.a2dBottomRight)
self.buttonsBackground.setBin('background', -90)
textureCard = loader.loadModel('models/minigames/pir_m_gui_pot_textureCard')
self.stretchedBackgroundTextureCard = textureCard.find('**/pir_t_gui_pot_background')
self.stretchedBackgroundTextureCard.reparentTo(self.background)
self.stretchedBackgroundTextureCard.setScale(3.3999999999999999, 1.0, 3.3999999999999999)
self.stretchedBackgroundTextureCard.setPos(0.0, 20.0, 0.0)
fadecm = CardMaker('card')
fadecm.setFrameFullscreenQuad()
self.fadeIn = render2d.attachNewNode(fadecm.generate())
self.fadeIn.setBin('background', -50)
self.fadeIn.setPos(0.0, -30.0, 0.0)
self.fadeIn.setColor(0, 0, 0, 1.0)
self.fadeIn.setTransparency(True)
base.loadingScreen.tick()
cm = CardMaker('card')
cm.setFrame(0, 1, 0.01, 0.01)
self.foregroundLayer = aspect2d.attachNewNode(cm.generate())
self.foregroundTextureCard = textureCard.find('**/pir_t_gui_pot_foreground')
self.foregroundTextureCard.setScale(0.80000000000000004, 1.0, 0.40000000000000002)
self.foregroundTextureCard.setPos(-0.69999999999999996, -20.0, 0.80000000000000004)
self.foregroundTextureCard.setBin('background', -80)
self.foregroundTextureCard.copyTo(self.foregroundLayer)
self.repMeter = ReputationMeter.ReputationMeter(InventoryType.PotionsRep, width = 0.56000000000000005)
inv = localAvatar.getInventory()
self.repMeter.reparentTo(self.xpBackground)
self.repMeter.setPos(0, 0, -0.94999999999999996)
self.repMeter.update(inv.getAccumulator(InventoryType.PotionsRep))
localAvatar.guiMgr.registerReputationHandler(self.updateRepMeter)
base.loadingScreen.tick()
self.closeButton = GuiButton.GuiButton(image = (textureCard.find('**/pir_t_gui_pot_escape'), textureCard.find('**/pir_t_gui_pot_escapeOn'), textureCard.find('**/pir_t_gui_pot_escapeOn'), textureCard.find('**/pir_t_gui_pot_escape')), image_scale = (0.10000000000000001, 0.10000000000000001, 0.10000000000000001), image_pos = (0.074999999999999997, 0, 0.080000000000000002), hotkeys = [
'Escape'], hotkeyLabel = PLocalizer.PotionGui['ExitButton'], pos = (-0.40000000000000002, 0.0, 0.01), text0_fg = PotionGlobals.TextColor, text1_fg = PiratesGuiGlobals.TextFG0, text2_fg = PiratesGuiGlobals.TextFG15, text3_fg = PotionGlobals.TextColorDisabled, parent = self.buttonsBackground, command = self.confirmQuit)
self.returnButton = GuiButton.GuiButton(text = (PLocalizer.PotionGui['SwitchRecipe'], PLocalizer.PotionGui['SwitchRecipe'], PLocalizer.PotionGui['SwitchRecipe'], PLocalizer.PotionGui['SwitchRecipe']), pos = (-0.57999999999999996, 0.0, -0.62), text_scale = PiratesGuiGlobals.TextScaleExtraLarge, text_shadow = None, image = (None, None, None, None), text0_fg = PotionGlobals.TextColor, text1_fg = PiratesGuiGlobals.TextFG0, text2_fg = PiratesGuiGlobals.TextFG15, text3_fg = PotionGlobals.TextColorDisabled, parent = self.background, command = self.confirmReturn)
self.returnButton.stash()
self.hintsButton = GuiButton.GuiButton(text = (PLocalizer.PotionGui['ShowTutorial'], PLocalizer.PotionGui['ShowTutorial'], PLocalizer.PotionGui['ShowTutorial'], PLocalizer.PotionGui['ShowTutorial']), text_scale = PiratesGuiGlobals.TextScaleSmall, image_scale = (0.25, 0.10000000000000001, 0.17999999999999999), image_pos = (0, 0, 0), pos = (-0.53000000000000003, 0.0, 0.074999999999999997), parent = self.buttonsBackground, command = self.showLastHint)
self.InfoButton = GuiButton.GuiButton(text = (PLocalizer.PotionGui['IngredientList'], PLocalizer.PotionGui['IngredientList'], PLocalizer.PotionGui['IngredientList'], PLocalizer.PotionGui['IngredientList']), text_scale = PiratesGuiGlobals.TextScaleSmall, image_scale = (0.29999999999999999, 0.10000000000000001, 0.17999999999999999), image_pos = (0, 0, 0), pos = (-0.83999999999999997, 0.0, 0.074999999999999997), parent = self.buttonsBackground, command = self.showInfo)
textureCard.removeNode()
base.loadingScreen.endStep('init Gui')
def _initGUI(self):
base.loadingScreen.beginStep('init Gui', 4, 55)
cm = CardMaker('PotionBackground')
cm.setFrame(-10, 10, -10, 10)
cm.setColor(0, 0, 0, 1)
self.background = NodePath(cm.generate())
self.background.reparentTo(aspect2d)
self.background.setBin('background', -100)
self.xpBackground = NodePath('PotionXPBackground')
self.xpBackground.reparentTo(aspect2d)
self.xpBackground.setBin('background', -95)
base.loadingScreen.tick()
self.dialogs = NodePath('DialogBackground')
self.dialogs.reparentTo(aspect2d)
self.dialogs.setBin('background', -70)
self.buttonsBackground = NodePath('PotionButtonBackground')
self.buttonsBackground.reparentTo(base.a2dBottomRight)
self.buttonsBackground.setBin('background', -90)
textureCard = loader.loadModel('models/minigames/pir_m_gui_pot_textureCard')
self.stretchedBackgroundTextureCard = textureCard.find('**/pir_t_gui_pot_background')
self.stretchedBackgroundTextureCard.reparentTo(self.background)
self.stretchedBackgroundTextureCard.setScale(3.3999999999999999, 1.0, 3.3999999999999999)
self.stretchedBackgroundTextureCard.setPos(0.0, 20.0, 0.0)
fadecm = CardMaker('card')
fadecm.setFrameFullscreenQuad()
self.fadeIn = render2d.attachNewNode(fadecm.generate())
self.fadeIn.setBin('background', -50)
self.fadeIn.setPos(0.0, -30.0, 0.0)
self.fadeIn.setColor(0, 0, 0, 1.0)
self.fadeIn.setTransparency(True)
base.loadingScreen.tick()
cm = CardMaker('card')
cm.setFrame(0, 1, 0.01, 0.01)
self.foregroundLayer = aspect2d.attachNewNode(cm.generate())
self.foregroundTextureCard = textureCard.find('**/pir_t_gui_pot_foreground')
self.foregroundTextureCard.setScale(0.80000000000000004, 1.0, 0.40000000000000002)
self.foregroundTextureCard.setPos(-0.69999999999999996, -20.0, 0.80000000000000004)
self.foregroundTextureCard.setBin('background', -80)
self.foregroundTextureCard.copyTo(self.foregroundLayer)
self.repMeter = ReputationMeter.ReputationMeter(InventoryType.PotionsRep, width = 0.56000000000000005)
inv = localAvatar.getInventory()
self.repMeter.reparentTo(self.xpBackground)
self.repMeter.setPos(0, 0, -0.94999999999999996)
self.repMeter.update(inv.getAccumulator(InventoryType.PotionsRep))
localAvatar.guiMgr.registerReputationHandler(self.updateRepMeter)
base.loadingScreen.tick()
self.closeButton = GuiButton.GuiButton(image = (textureCard.find('**/pir_t_gui_pot_escape'), textureCard.find('**/pir_t_gui_pot_escapeOn'), textureCard.find('**/pir_t_gui_pot_escapeOn'), textureCard.find('**/pir_t_gui_pot_escape')), image_scale = (0.10000000000000001, 0.10000000000000001, 0.10000000000000001), image_pos = (0.074999999999999997, 0, 0.080000000000000002), hotkeys = [
'Escape'], hotkeyLabel = PLocalizer.PotionGui['ExitButton'], pos = (-0.40000000000000002, 0.0, 0.01), text0_fg = PotionGlobals.TextColor, text1_fg = PiratesGuiGlobals.TextFG0, text2_fg = PiratesGuiGlobals.TextFG15, text3_fg = PotionGlobals.TextColorDisabled, parent = self.buttonsBackground, command = self.confirmQuit)
self.returnButton = GuiButton.GuiButton(text = (PLocalizer.PotionGui['SwitchRecipe'], PLocalizer.PotionGui['SwitchRecipe'], PLocalizer.PotionGui['SwitchRecipe'], PLocalizer.PotionGui['SwitchRecipe']), pos = (-0.57999999999999996, 0.0, -0.62), text_scale = PiratesGuiGlobals.TextScaleExtraLarge, text_shadow = None, image = (None, None, None, None), text0_fg = PotionGlobals.TextColor, text1_fg = PiratesGuiGlobals.TextFG0, text2_fg = PiratesGuiGlobals.TextFG15, text3_fg = PotionGlobals.TextColorDisabled, parent = self.background, command = self.confirmReturn)
self.returnButton.stash()
self.hintsButton = GuiButton.GuiButton(text = (PLocalizer.PotionGui['ShowTutorial'], PLocalizer.PotionGui['ShowTutorial'], PLocalizer.PotionGui['ShowTutorial'], PLocalizer.PotionGui['ShowTutorial']), text_scale = PiratesGuiGlobals.TextScaleSmall, image_scale = (0.25, 0.10000000000000001, 0.17999999999999999), image_pos = (0, 0, 0), pos = (-0.53000000000000003, 0.0, 0.074999999999999997), parent = self.buttonsBackground, command = self.showLastHint)
self.InfoButton = GuiButton.GuiButton(text = (PLocalizer.PotionGui['IngredientList'], PLocalizer.PotionGui['IngredientList'], PLocalizer.PotionGui['IngredientList'], PLocalizer.PotionGui['IngredientList']), text_scale = PiratesGuiGlobals.TextScaleSmall, image_scale = (0.29999999999999999, 0.10000000000000001, 0.17999999999999999), image_pos = (0, 0, 0), pos = (-0.83999999999999997, 0.0, 0.074999999999999997), parent = self.buttonsBackground, command = self.showInfo)
textureCard.removeNode()
base.loadingScreen.endStep('init Gui')
def __init__(self, x1, y1, x2, y2, z):
Att_base.__init__(self, False, "Water1")
# Water surface
maker = CardMaker( 'water' )
maker.setFrame( x1, x2, y1, y2 )
self.waterNP = render.attachNewNode(maker.generate())
self.waterNP.setHpr(0,-90,0)
self.waterNP.setPos(0,0,z)
self.waterNP.setTransparency(TransparencyAttrib.MAlpha )
self.waterNP.setShader(loader.loadShader( 'Shaders/water1.sha' ))
# Reflection plane
self.waterPlane = Plane( Vec3( 0, 0, z+1 ), Point3( 0, 0, z ) )
planeNode = PlaneNode( 'waterPlane' )
planeNode.setPlane( self.waterPlane )
# Buffer and reflection camera
self.buffer = base.win.makeTextureBuffer( 'waterBuffer', 512, 512 )
self.buffer.setClearColor( Vec4( 0, 0, 0, 1 ) )
cfa = CullFaceAttrib.makeReverse( )
rs = RenderState.make(cfa)
self.watercamNP = base.makeCamera( self.buffer )
self.watercamNP.reparentTo(render)
sa = ShaderAttrib.make()
sa = sa.setShader(loader.loadShader('Shaders/splut3Clipped.sha') )
self.cam = self.watercamNP.node()
self.cam.getLens( ).setFov( base.camLens.getFov( ) )
self.cam.getLens().setNear(1)
self.cam.getLens().setFar(5000)
self.cam.setInitialState( rs )
self.cam.setTagStateKey('Clipped')
self.cam.setTagState('True', RenderState.make(sa))
# ---- water textures ---------------------------------------------
# reflection texture, created in realtime by the 'water camera'
tex0 = self.buffer.getTexture( )
tex0.setWrapU(Texture.WMClamp)
tex0.setWrapV(Texture.WMClamp)
ts0 = TextureStage( 'reflection' )
self.waterNP.setTexture( ts0, tex0 )
# distortion texture
tex1 = loader.loadTexture('Textures/water.png')
ts1 = TextureStage('distortion')
self.waterNP.setTexture(ts1, tex1)
def make_vertical_wall(self, pos):
x, y = pos
cm = CardMaker("wall")
cm.setFrame(0, 1, 0, 2)
front_card = cm.generate()
front = self.render.attachNewNode(front_card)
front.setH(0)
front.setPos(x,y,0)
back_card = cm.generate()
back = self.render.attachNewNode(back_card)
back.setH(180)
back.setPos(x+1,y,0)
def makeCard(self, color, width, height, i, j, divisions):
divisions = float(divisions)
x = i / divisions
y = j / divisions
d = 1 / divisions
card = CardMaker("wall")
card.setColor(*color)
card.setFrame(width*(x*2-1), width*((x+d)*2-1), height*(y*2-1), height*((y+d)*2-1))
card.setUvRange(Point2(width*x, height*y), Point2(width*(x+d), height*(y+d)))
card.setHasUvs(True)
card.setHasNormals(True)
node = self.node.attachNewNode(card.generate())
def _initVisuals(self):
RepairMincroGame._initVisuals(self)
self.model = loader.loadModel('models/gui/pir_m_gui_srp_pumping_main')
self.visual = self.attachNewNode('visual')
self.visual.setPos(-0.25, 0.0, 0.074999999999999997)
goalTopLoc = self.model.find('**/locator_top')
goalTopLoc.reparentTo(self.visual)
goalBottomLoc = self.model.find('**/locator_bottom')
goalBottomLoc.reparentTo(self.visual)
self.goalPositions = (goalBottomLoc.getPos(self), goalTopLoc.getPos(self))
self.greatLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Great, text_fg = (0.20000000000000001, 0.80000000000000004, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ACenter, text_font = PiratesGlobals.getPirateFont(), relief = None, text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.46500000000000002, 0.0, 0.0), parent = self)
self.failLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Fail, text_fg = (0.80000000000000004, 0.20000000000000001, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ARight, text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.625, 0.0, 0.0), parent = self)
self.shipBackground = self.model.find('**/static_ship_background')
self.shipBackground.reparentTo(self.visual)
self.waterMeter = self.model.find('**/sprite_waterBottom')
self.waterMeter.reparentTo(self.visual)
self.waterTop = self.model.find('**/sprite_waterTop')
self.waterTop.reparentTo(self.visual)
self.waterMeterTopLoc = self.waterMeter.find('**/locator_topOfShipWater')
self.pumpBackground = self.model.find('**/pumpBackground')
self.pumpBackground.reparentTo(self.visual)
self.pumpWaterTop = self.model.find('**/sprite_pumpWaterTop')
self.pumpWaterTop.reparentTo(self.visual)
self.pumpWaterBottom = self.model.find('**/sprite_pumpWaterBottom')
self.pumpWaterBottom.reparentTo(self.visual)
self.pumpWaterTopLoc = self.pumpWaterBottom.find('**/locator_topOfPumpWater')
self.pumpHandle = self.model.find('**/sprite_handle')
self.pumpHandle.reparentTo(self.visual)
self.pumpBar = self.model.find('**/static_pump')
self.pumpBar.reparentTo(self.visual)
self.goalBox = self.model.find('**/sprite_clickField')
self.goalBox.reparentTo(self.visual)
self.goalBox.setTransparency(1)
self.enableGoalBox()
self.pumpLine = self.model.find('**/sprite_bar')
self.pumpLine.reparentTo(self.visual)
self.ghostLine = self.visual.attachNewNode('ghostLine')
self.pumpLine.getChild(0).copyTo(self.ghostLine)
self.ghostLine.setScale(self.pumpLine.getScale())
self.ghostLine.setColor(1.0, 0.20000000000000001, 0.20000000000000001, 1.0)
self.shipForground = self.model.find('**/static_ship_foreground')
self.shipForground.reparentTo(self.visual)
cm = CardMaker('cardMaker')
cm.setFrame(-0.33000000000000002, 0.33000000000000002, 0.0, 1.0)
self.goalBox.setZ(self.goalPositions[TOP].getZ())
self.goalBoxStartScale = self.goalBox.getSz()
self.enableGoalBox()
self.pumpWaterUpLerp = LerpFunc(self.setPumpWater, fromData = -0.10000000000000001, toData = 1.0, duration = 0.5)
self.pumpWaterDownLerp = LerpFunc(self.setPumpWater, fromData = 1.0, toData = -0.10000000000000001, duration = 0.5)
self.model.removeNode()
del self.model
def _initVisuals(self):
RepairMincroGame._initVisuals(self)
self.model = loader.loadModel('models/gui/pir_m_gui_srp_pumping_main')
self.visual = self.attachNewNode('visual')
self.visual.setPos(-0.25, 0.0, 0.074999999999999997)
goalTopLoc = self.model.find('**/locator_top')
goalTopLoc.reparentTo(self.visual)
goalBottomLoc = self.model.find('**/locator_bottom')
goalBottomLoc.reparentTo(self.visual)
self.goalPositions = (goalBottomLoc.getPos(self), goalTopLoc.getPos(self))
self.greatLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Great, text_fg = (0.20000000000000001, 0.80000000000000004, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ACenter, text_font = PiratesGlobals.getPirateFont(), relief = None, text_shadow = (0.0, 0.0, 0.0, 1.0), scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.46500000000000002, 0.0, 0.0), parent = self)
self.failLabel = DirectLabel(text = PLocalizer.Minigame_Repair_Pumping_Fail, text_fg = (0.80000000000000004, 0.20000000000000001, 0.29999999999999999, 1.0), text_pos = (0.0, 0.59999999999999998), text_align = TextNode.ARight, text_font = PiratesGlobals.getPirateFont(), text_shadow = (0.0, 0.0, 0.0, 1.0), relief = None, scale = (0.080000000000000002, 0.080000000000000002, 0.080000000000000002), pos = (-0.625, 0.0, 0.0), parent = self)
self.shipBackground = self.model.find('**/static_ship_background')
self.shipBackground.reparentTo(self.visual)
self.waterMeter = self.model.find('**/sprite_waterBottom')
self.waterMeter.reparentTo(self.visual)
self.waterTop = self.model.find('**/sprite_waterTop')
self.waterTop.reparentTo(self.visual)
self.waterMeterTopLoc = self.waterMeter.find('**/locator_topOfShipWater')
self.pumpBackground = self.model.find('**/pumpBackground')
self.pumpBackground.reparentTo(self.visual)
self.pumpWaterTop = self.model.find('**/sprite_pumpWaterTop')
self.pumpWaterTop.reparentTo(self.visual)
self.pumpWaterBottom = self.model.find('**/sprite_pumpWaterBottom')
self.pumpWaterBottom.reparentTo(self.visual)
self.pumpWaterTopLoc = self.pumpWaterBottom.find('**/locator_topOfPumpWater')
self.pumpHandle = self.model.find('**/sprite_handle')
self.pumpHandle.reparentTo(self.visual)
self.pumpBar = self.model.find('**/static_pump')
self.pumpBar.reparentTo(self.visual)
self.goalBox = self.model.find('**/sprite_clickField')
self.goalBox.reparentTo(self.visual)
self.goalBox.setTransparency(1)
self.enableGoalBox()
self.pumpLine = self.model.find('**/sprite_bar')
self.pumpLine.reparentTo(self.visual)
self.ghostLine = self.visual.attachNewNode('ghostLine')
self.pumpLine.getChild(0).copyTo(self.ghostLine)
self.ghostLine.setScale(self.pumpLine.getScale())
self.ghostLine.setColor(1.0, 0.20000000000000001, 0.20000000000000001, 1.0)
self.shipForground = self.model.find('**/static_ship_foreground')
self.shipForground.reparentTo(self.visual)
cm = CardMaker('cardMaker')
cm.setFrame(-0.33000000000000002, 0.33000000000000002, 0.0, 1.0)
self.goalBox.setZ(self.goalPositions[TOP].getZ())
self.goalBoxStartScale = self.goalBox.getSz()
self.enableGoalBox()
self.pumpWaterUpLerp = LerpFunc(self.setPumpWater, fromData = -0.10000000000000001, toData = 1.0, duration = 0.5)
self.pumpWaterDownLerp = LerpFunc(self.setPumpWater, fromData = 1.0, toData = -0.10000000000000001, duration = 0.5)
self.model.removeNode()
del self.model
def __init__(self, listConsideration=[]):
z = -0.05
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
cm = CardMaker("blah")
cm.setFrame(-100, 100, -100, 100)
render.attachNewNode(cm.generate()).lookAt(0, 0, -1)
#Create a selection window using cardmaker
#We will use the setScale function to dynamically scale the quad to the appropriate size in UpdateSelRect
temp = CardMaker('')
temp.setFrame(0, 1, 0, 1)
#self.npSelRect is the actual selection rectangle that we dynamically hide/unhide and change size
self.npSelRect = render2d.attachNewNode(temp.generate())
self.npSelRect.setColor(0.5,1,0,.3)
self.npSelRect.setTransparency(1)
self.npSelRect.hide()
LS = LineSegs()
LS.setColor(0.5,1,0,1)
LS.moveTo(0,0,0)
LS.drawTo(1,0,0)
LS.drawTo(1,0,1)
LS.drawTo(0,0,1)
LS.drawTo(0,0,0)
self.npSelRect.attachNewNode(LS.create())
self.listConsideration = listConsideration
self.listSelected = []
self.listLastSelected = []
self.pt2InitialMousePos = (-12, -12)
self.pt2LastMousePos = (-12, -12)
####----Used to differentiate between group selections and point selections
#self.booMouseMoved = False
self.fFovh, self.fFovv = base.camLens.getFov()
####--Used to control how frequently update_rect is updated;
self.fTimeLastUpdateSelRect = 0
self.fTimeLastUpdateSelected = 0
self.UpdateTimeSelRect = 0.015
self.UpdateTimeSelected = 0.015
####------Register the left-mouse-button to start selecting
self.accept("mouse1", self.OnStartSelect)
self.accept("control-mouse1", self.OnStartSelect)
self.accept("mouse1-up", self.OnStopSelect)
self.taskUpdateSelRect = 0
####------otherThings
self.booSelecting = False
def __init__(self,width,height,texture,scale):
self.width = width*scale
self.height = height*scale
print texture
self.texture = loader.loadTexture(texture)
cm = CardMaker("CardMaker")
cm.setFrame((self.width/2,self.height/2,0),(-self.width/2,self.height/2,0),(-self.width/2,-self.height/2,0),(self.width/2,-self.height/2,0))
card = render.attachNewNode(cm.generate())
card.clearColor()
card.setBin("background", 10)
card.setHpr(180,0,0)
card.setTransparency(TransparencyAttrib.MAlpha)
card.setTexture(self.texture)
def makeCard(self, color, width, height, i, j, divisions):
divisions = float(divisions)
x = i / divisions
y = j / divisions
d = 1 / divisions
card = CardMaker("wall")
card.setColor(*color)
card.setFrame(width * (x * 2 - 1), width * ((x + d) * 2 - 1),
height * (y * 2 - 1), height * ((y + d) * 2 - 1))
card.setUvRange(Point2(width * x, height * y),
Point2(width * (x + d), height * (y + d)))
card.setHasUvs(True)
card.setHasNormals(True)
node = self.node.attachNewNode(card.generate())
def setSky(directory, ext=".jpg"):
"""Sets up a skybox. 'directory' is the directory whitch contains 6
pictures with the names right.ext, left.ext and so on (see template).
ext is the extension the pictures have (with dot).
"""
#TODO: accept all supported image file extensions without the need for an
# extra argument
# remove the old sky first when loading a new one
# TODO: get this working...
#oldsky = render.find("*sky*")
#print oldsky
#for child in render.getChildren():
# child.remove()
sky = NodePath().attachNewNode("sky")
sides = {
"right": ( 1, 0, 0, -90, 0, 0),
"left": (-1, 0, 0, 90, 0, 0),
"top": ( 0, 0, 1, 0, 90, 0),
"bottom": ( 0, 0, -1, 180, -90, 0),
"front": ( 0, 1, 0, 0, 0, 0),
"back": ( 0, -1, 0, 180, 0, 0)
}
for name, poshpr in sides.iteritems():
c = CardMaker(name)
c.setFrame(-1, 1, -1, 1)
card = c.generate()
cardnode = sky.attachNewNode(card)
cardnode.setPosHpr(*poshpr)
tex = loader.loadTexture("skyboxes/" + directory + "/" + name + ext)
tex.setWrapV(tex.WMClamp)
tex.setMagfilter(tex.FTNearestMipmapNearest)
tex.setMinfilter(tex.FTNearestMipmapNearest)
cardnode.setTexture(tex)
sky.flattenStrong()
sky.setScale(10, 10, 10)
sky.setCompass()
sky.setBin('background', 0)
sky.setDepthTest(False)
sky.setDepthWrite(False)
sky.setLightOff()
sky.reparentTo(camera)
geom = sky.getChild(0).node()
geom.setName("cube")
def __init__(self, potionGame):
self.numColumns = 8
self.numRows = 10
DirectFrame.__init__(self, parent = potionGame.background, relief = None)
cm = CardMaker('card')
cm.setFrame(0, 0, 1.0, 1.0)
self.background = self.attachNewNode(cm.generate())
self.background.setColor(0.20000000000000001, 0.20000000000000001, 0.20000000000000001, 1)
self.potionGame = potionGame
self.pieceDropped = False
self.pieceFlipped = False
self.pieceNotDropped = False
self.delayDropped = False
self.experementMatched = False
self.experementFailed = False
self.initBoard()
def createSprite(self,filename, x, z, sx, sz, transparent = 1):
cm = CardMaker('spritesMaker')
cm.setFrame(-0.5, 0.5, -0.5, 0.5)
sprite = cm.generate()
tex = loader.loadTexture(filename)
spriteNP = NodePath(sprite)
spriteNP.setTexture(tex)
spriteNP.setPos(x, 0, z)
spriteNP.setScale(sx, 1.0, sz)
spriteNP.setTransparency(transparent)
return spriteNP
def __init__(self, scale=1, value=1, r=1, g=0, b=0):
NodePath.__init__(self, 'healthbar')
self.scale = scale
cmfg = CardMaker('fg')
cmfg.setFrame(- scale, scale, -0.1 * scale, 0.1 * scale)
self.fg = self.attachNewNode(cmfg.generate())
cmbg = CardMaker('bg')
cmbg.setFrame(- scale, scale, -0.1 * scale, 0.1 * scale)
self.bg = self.attachNewNode(cmbg.generate())
self.fg.setColor(r, g, b, 1)
self.bg.setColor(0.2, 0.2, 0.2, 1)
self.setValue(value)
def _createMapTextureCard(self):
"""
This will return a NodePath with a card textured with the minimap. The
minimap texture is dynamically created from the map data.
"""
# create and fill empty map image
mapImage = PNMImage(MAP_RESOLUTION, MAP_RESOLUTION)
blockFiles = []
for i in range(5):
blockFiles.append(PNMImage())
#blockFiles[i].read(Filename("mapBlock%i.jpg"%(i+1)))
# TODO:maze either reference a set of textures for each piece or fill with color
blockFiles[i].read(Filename('phase_4/maps/male_sleeve4New.jpg'))
mapImage.fill(0.8, 0.8, 0.8)
# iterate through the map data and place a block in the map image where appropriate
for x in range( len(self._mazeLayout[0]) ):
for y in range( len(self._mazeLayout) ):
if self._mazeLayout[y][x]:
ax = float(x)/len(self._mazeLayout[0]) * MAP_RESOLUTION
ay = float(y)/len(self._mazeLayout) * MAP_RESOLUTION
#TODO:maze use different blocks for different wall types or items
#mapImage.copySubImage(random.choice(blockFiles), int(ax), int(ay), 20, 20, 32, 32)
#TODO:maze find the ideal block texture size for the map so we dont
# have to do this strange offset
#mapImage.copySubImage(blockFiles[0], int(ax), int(ay), 0, 0, 32, 32)
self._drawSquare(mapImage, int(ax), int(ay), 10, VBase4D(0.5, 0.5, 0.5, 1.0))
# create a texture from the map image
mapTexture = Texture("mapTexture")
mapTexture.setupTexture(Texture.TT2dTexture, self._maskResolution, self._maskResolution, 1, Texture.TUnsignedByte, Texture.FRgba)
mapTexture.setMinfilter(Texture.FTLinear)
mapTexture.load(mapImage)
mapTexture.setWrapU(Texture.WMClamp)
mapTexture.setWrapV(Texture.WMClamp)
mapImage.clear()
del mapImage
# put the texture on a card and return it
cm = CardMaker("map_cardMaker")
cm.setFrame(-1.0,1.0,-1.0,1.0)
map = self.attachNewNode(cm.generate())
map.setTexture(mapTexture, 1)
return map
class BulletHoles:
"""The name says it all."""
def __init__(self, manager, xml):
self.texture = loader.loadTexture('data/textures/bullet-hole.png')
self.texture.setMinfilter(Texture.FTLinearMipmapLinear)
self.container = render.attachNewNode(ModelRoot('bullet-holes'))
self.card = CardMaker('bullet-hole')
s = BULLETHOLE_SIZE * 0.5
self.card.setFrame(-s, s, -s, s)
self.card.setUvRange(Point2(0, 0), Point2(1, 1))
def makeNew(self, pos, nor, parent=None):
"""Makes a new bullet hole."""
if parent == None:
parent = self.container
else:
# Add a subnode to the parent, if it's not already there
child = parent.find('bullet-holes')
if child.isEmpty():
parent = parent.attachNewNode('bullet-holes')
else:
parent = child
newhole = NodePath(self.card.generate())
newhole.reparentTo(parent)
newhole.lookAt(render, Point3(newhole.getPos(render) - nor))
newhole.setR(newhole, random() * 360.0)
newhole.setPos(render, pos)
# Offset it a little to avoid z-fighting
# Increase this value if you still see it.
newhole.setY(newhole, -.001 - random() * 0.01)
del newhole
# We don't want one batch per bullet hole, so flatten it.
# This could be made smarter to preserve culling, but
# I have yet to see a performance loss.
# The clearTexture() is a necessary hack.
parent.clearTexture()
parent.flattenStrong()
parent.setTexture(self.texture)
parent.setTransparency(TransparencyAttrib.MDual)
parent.setShaderOff(1)
parent.hide(BitMask32.bit(
2)) # Invisible to volumetric lighting camera (speedup)
parent.hide(BitMask32.bit(3)) # Invisible to shadow cameras (speedup)
def destroy(self):
self.container.removeNode()
def __init__(self, potionGame):
self.numColumns = 8
self.numRows = 10
DirectFrame.__init__(self, parent=potionGame.background, relief=None)
cm = CardMaker('card')
cm.setFrame(0, 0, 1.0, 1.0)
self.background = self.attachNewNode(cm.generate())
self.background.setColor(0.2, 0.2, 0.2, 1)
self.potionGame = potionGame
self.pieceDropped = False
self.pieceFlipped = False
self.pieceNotDropped = False
self.delayDropped = False
self.experementMatched = False
self.experementFailed = False
self.initBoard()
return
def load_floor(self):
cm = CardMaker("floor")
cm.setFrame(0, 1, 0, 1)
card = cm.generate()
grass_texture = self.loader.loadTexture(os.path.join("data", "images", "grass.png"))
wood_texture = self.loader.loadTexture(os.path.join("data", "images", "floor_wood_0.png"))
for x, row in enumerate(self.floor_data.layout):
for y, tile in enumerate(row):
floor = self.render.attachNewNode(cm.generate())
floor.setP(270)
floor.setPos(x,y,0)
if tile == floor_layout.GRASS:
floor.setTexture(grass_texture)
elif tile == floor_layout.WOOD:
floor.setTexture(wood_texture)
def create_floor(self, size_x_axis, size_y_axis, texture):
card_maker = CardMaker('')
card_maker.setFrame(0,size_x_axis,0,size_y_axis)
'''
for y in range(size_y_axis):
for x in range(size_x_axis):
new_node = self.floorNode.attachNewNode(card_maker.generate())
new_node.setP(-90)
new_node.setPos(x, y, 0)
'''
new_node = self.floor_node.attachNewNode(card_maker.generate())
new_node.setP(-90)
new_node.setPos(0, 0, 0)
new_node.setTexture(textures[texture])
self.floor_node.flattenStrong()
class BulletHoles:
"""The name says it all."""
def __init__(self,manager,xml):
self.texture = loader.loadTexture('data/textures/bullet-hole.png')
self.texture.setMinfilter(Texture.FTLinearMipmapLinear)
self.container = render.attachNewNode(ModelRoot('bullet-holes'))
self.card = CardMaker('bullet-hole')
s = BULLETHOLE_SIZE * 0.5
self.card.setFrame(-s, s, -s, s)
self.card.setUvRange(Point2(0, 0), Point2(1, 1))
def makeNew(self, pos, nor, parent = None):
"""Makes a new bullet hole."""
if parent == None:
parent = self.container
else:
# Add a subnode to the parent, if it's not already there
child = parent.find('bullet-holes')
if child.isEmpty():
parent = parent.attachNewNode('bullet-holes')
else:
parent = child
newhole = NodePath(self.card.generate())
newhole.reparentTo(parent)
newhole.lookAt(render, Point3(newhole.getPos(render) - nor))
newhole.setR(newhole, random() * 360.0)
newhole.setPos(render, pos)
# Offset it a little to avoid z-fighting
# Increase this value if you still see it.
newhole.setY(newhole, -.001 - random() * 0.01)
del newhole
# We don't want one batch per bullet hole, so flatten it.
# This could be made smarter to preserve culling, but
# I have yet to see a performance loss.
# The clearTexture() is a necessary hack.
parent.clearTexture()
parent.flattenStrong()
parent.setTexture(self.texture)
parent.setTransparency(TransparencyAttrib.MDual)
parent.setShaderOff(1)
parent.hide(BitMask32.bit(2)) # Invisible to volumetric lighting camera (speedup)
parent.hide(BitMask32.bit(3)) # Invisible to shadow cameras (speedup)
def destroy(self):
self.container.removeNode()
def __init__(self,
name,
nrplates,
width,
height,
shaderfile,
texturefile,
uvlist,
jitter=-1):
#print name, nrplates, width, height, shaderfile, texturefile, uvlist, jitter
self.name = name
self.texturefile = texturefile
self.shaderfile = shaderfile
self.np = NodePath('leaf')
self.tex = loader.loadTexture('textures/' + texturefile)
self.tex.setMinfilter(Texture.FTLinearMipmapLinear)
self.tex.setMagfilter(Texture.FTLinearMipmapLinear)
self.tex.setAnisotropicDegree(2)
self.np.setTexture(self.tex)
self.np.setTwoSided(True)
self.np.setTransparency(TransparencyAttrib.MAlpha)
#self.np.setTransparency( TransparencyAttrib.MMultisample )
self.np.setDepthWrite(False)
maker = CardMaker('leaf')
maker.setFrame(-width / 2.0, width / 2.0, 0, height)
#maker.setFrame( 0,1,0,1)
for i in range(nrplates):
if uvlist != None:
maker.setUvRange(uvlist[i][0], uvlist[i][1])
else:
maker.setUvRange(Point2(0, 0), Point2(1, 0.98))
node = self.np.attachNewNode(maker.generate())
#node.setTwoSided( True )
node.setHpr(i * 180.0 / nrplates, 0, 0)
self.np.flattenStrong()
#np.flattenLight()
#np.setTwoSided( True )
if jitter == -1:
self.jitter = height / width / 2
else:
self.jitter = jitter
def __init__(self, width, height, texture, scale):
self.width = width * scale
self.height = height * scale
self.texture = loader.loadTexture(
texture) #"textures/map/"+texture+".jpg")
cm = CardMaker("CardMaker")
cm.setFrame((self.width / 2, self.height / 2, 0),
(-self.width / 2, self.height / 2, 0),
(-self.width / 2, -self.height / 2, 0),
(self.width / 2, -self.height / 2, 0))
card = render.attachNewNode(cm.generate())
card.clearColor()
card.setBin("background", 10)
card.setHpr(180, 0, 0)
card.setTransparency(TransparencyAttrib.MAlpha)
card.setTexture(self.texture)
def __setupEnvironment(self):
cm = CardMaker("ground")
size = 200
cm.setFrame(-size, size, -size, size)
environment = render.attachNewNode(cm.generate())
environment.lookAt(0, 0, -1)
environment.setPos(100, -100, 0)
environment.setCollideMask(BitMask32.allOn())
environment.reparentTo(render)
texture = loader.loadTexture("textures/ground.png")
# This is so the textures can look better from a distance
texture.setMinfilter(Texture.FTLinearMipmapLinear)
environment.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition)
environment.setTexScale(TextureStage.getDefault(), 0.02, 0.02)
environment.setTexture(texture, 1)
def addLock(self, x, y, color):
"""
Adds a lock to the minimap. This will add a colored dot to the map
that represents a lock.
--- This is subject to change pending a new player-lock data system. ---
"""
assert self.notify.debugCall()
x, y = self._tileToActualPosition(x, y)
# TODO:maze: replace with lock model / texture
cm = CardMaker("lock_cardMaker")
cm.setFrame(-0.04,0.04,-0.04,0.04)
lock = self.maskedLayer.attachNewNode(cm.generate())
lock.setColor(color)
lock.setPos(x/self._maskResolution*2.0 - 0.97, 0, y/self._maskResolution*-2.0 + 1.02)
self._locks.append(lock)
def createImageSprite3D(resources, sprite, parent=None):
"""
Creates a node responsible for rendering a sprite whose visual representation consists of a single image.
We use the CardMaker in order to generate a quad where the image will be applied as a texture.
Returns: the NodePath for the created node.
"""
tex = resources.loadTexture(sprite.image)
cm = CardMaker(sprite.name)
cm.setFrame(-0.5, 0.5, -0.5, 0.5)
cm.setColor(1, 1, 1, 1)
if parent is not None:
card = parent.attachNewNode(cm.generate())
else:
card = NodePath(cm.generate())
card.setTexture(tex)
card.setPythonTag('sprite', sprite)
return card
def __setupEnvironment(self):
cm = CardMaker("ground")
size = 100
cm.setFrame(-size, size, -size, size)
environment = render.attachNewNode(cm.generate())
environment.lookAt(0, 0, -1)
environment.setPos(0, 0, 0)
environment.setCollideMask(BitMask32.allOn())
environment.reparentTo(render)
texture = loader.loadTexture("textures/ground.png")
# This is so the textures can look better from a distance
texture.setMinfilter(Texture.FTLinearMipmapLinear)
environment.setTexGen(TextureStage.getDefault(),
TexGenAttrib.MWorldPosition)
environment.setTexScale(TextureStage.getDefault(), 0.02, 0.02)
environment.setTexture(texture, 1)
def _createMaskTextureCard(self):
self._maskImage = PNMImage(self._maskResolution, self._maskResolution, 4)
for x in xrange(self._maskResolution):
for y in xrange(self._maskResolution):
self._maskImage.setXelA(x, y, 0, 0, 0, 1)
self.maskTexture = Texture('maskTexture')
self.maskTexture.setupTexture(Texture.TT2dTexture, self._maskResolution, self._maskResolution, 1, Texture.TUnsignedByte, Texture.FRgba)
self.maskTexture.setMinfilter(Texture.FTLinear)
self.maskTexture.setWrapU(Texture.WMClamp)
self.maskTexture.setWrapV(Texture.WMClamp)
self.maskTexture.load(self._maskImage)
base.graphicsEngine.renderFrame()
cm = CardMaker('mask_cardMaker')
cm.setFrame(-1.1, 1.1, -1.1, 1.1)
mask = self.attachNewNode(cm.generate())
mask.setTexture(self.maskTexture, 1)
mask.setTransparency(1)
return mask
def _createMaskTextureCard(self):
self._maskImage = PNMImage(self._maskResolution, self._maskResolution, 4)
for x in range(self._maskResolution):
for y in range(self._maskResolution):
self._maskImage.setXelA(x, y, 0, 0, 0, 1)
self.maskTexture = Texture('maskTexture')
self.maskTexture.setupTexture(Texture.TT2dTexture, self._maskResolution, self._maskResolution, 1, Texture.TUnsignedByte, Texture.FRgba)
self.maskTexture.setMinfilter(Texture.FTLinear)
self.maskTexture.setWrapU(Texture.WMClamp)
self.maskTexture.setWrapV(Texture.WMClamp)
self.maskTexture.load(self._maskImage)
base.graphicsEngine.renderFrame()
cm = CardMaker('mask_cardMaker')
cm.setFrame(-1.1, 1.1, -1.1, 1.1)
mask = self.attachNewNode(cm.generate())
mask.setTexture(self.maskTexture, 1)
mask.setTransparency(1)
return mask
def __init__(self, scale=1.2):
NodePath.__init__(self, 'healthbar')
self.scale = scale
cmfg = CardMaker('fg')
cmfg.setFrame(- scale, scale, -0.1 * scale, 0.1 * scale)
self.fg = self.attachNewNode(cmfg.generate())
cmbg = CardMaker('bg')
cmbg.setFrame(- scale, scale, -0.1 * scale, 0.1 * scale)
self.bg = self.attachNewNode(cmbg.generate())
#cmbd = CardMaker('bd')
#cmbd.setFrame(- scale * 1.3, scale * 1.3, -.2 * scale, .2 * scale)
#self.bd = self.attachNewNode(cmbd.generate())
self.fg.setColor(1, 0, 0, 1)
self.bg.setColor(0.2, 0.2, 0.2, 1)
self.setValue(1)
def __init__( self ):
# disable the default camera control
base.disableMouse()
# create the aiming cross
cm = CardMaker('aim-cross')
cm.setFrame(-AIMCROSSWIDTH,AIMCROSSWIDTH,-AIMCROSSHEIGHT,AIMCROSSHEIGHT)
cross = cm.generate()
self.aimingCross = NodePath(cross)
# set texture to cross
tex = loader.loadTexture(CROSSTEXTURE)
self.aimingCross.setTexture(tex)
# enable transparency on the aiming cross
self.aimingCross.setTransparency(TransparencyAttrib.MAlpha)
self.aimingCross.detachNode()
# enable this class functions
self.enable()
self.accept( 'space', self.toggle )
def __init__(self,pickableList = []):
self.pickable = pickableList
tempCard = CardMaker('')
tempCard.setFrame(0,1,0,1)
#Lets render our frame so we can hide / show /resize it as needed
self.selectFrame = render2d.attachNewNode(tempCard.generate())
self.selectFrame.setColor(1,1,0,.2)
self.selectFrame.setTransparency(1)
self.selectFrame.hide()
#Set up our line segmants for a border
ls = LineSegs()
ls.moveTo(0,0,0)
ls.drawTo(1,0,0)
ls.drawTo(1,0,1)
ls.drawTo(0,0,1)
ls.drawTo(0,0,0)
self.selectFrame.attachNewNode(ls.create())
self.selected = []
self.previousSelect = []
self.selectable = []
#Init our mouse locations
self.pt2InitMousePos = (-1,-1)
self.pt2LastMousePos = (-1,-1)
self.fFovh , self.fFovv = base.camLens.getFov()
self.fTimeLastUpdateRect = 0
self.fTimeLastUpdateSelected = 0
self.UpdateTimeRect = 0.015
self.UpdateTimeSelected = 0.015
print "Running Select Tools"
self.accept("mouse1",self.OnStartSelect)
self.accept("control-mouse1",self.OnStartSelect)
self.accept("mouse1-up",self.OnMouseRelease)
self.taskUpdateSelectRect = 0
def __setupPreview(self):
"""Creates the preview."""
if not self.previewCheck.Value: return
if self.preview != None:
self.__destroyPreview()
self.preview = wx.StaticBitmap(self, style = wx.SUNKEN_BORDER, size = PREVIEW_SIZE)
self.sizer.Add(self.preview, 0, wx.ADJUST_MINSIZE | wx.ALIGN_CENTER, 0)
cm = CardMaker("preview")
cm.setFrame(-1, 1, -1, 1)
cm.setUvRange(Point2(0, 0), Point2(1, 1))
self.previewTexture = Texture()
self.previewBuffer = WindowManager.windows[0].win.makeTextureBuffer("preview", *PREVIEW_SIZE)
self.previewBuffer.setClearColor(Vec4(1, 1, 1, 1))
self.previewCamera = base.makeCamera2d(self.previewBuffer)
self.previewPlane = NodePath(cm.generate())
self.previewPlane.setFogOff(1000)
self.previewPlane.setLightOff(1000)
self.previewCamera.node().setScene(self.previewPlane)
self.previewBuffer.addRenderTexture(self.previewTexture, GraphicsOutput.RTMCopyRam)
self.previewCamera.node().setActive(texturePainter.texturePainterStatus == TEXTURE_PAINTER_STATUS_ENABLED)
self.Layout()