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 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 _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 _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 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 __init__(self,
scene=base.render,
ambient=0.2,
hardness=16,
fov=40,
near=10,
far=100):
"""Create an instance of this class to initiate shadows.
Also, a shadow casting 'light' is created when this class is called.
The first parameter is the nodepath in the scene where you
want to apply your shadows on, by default this is render."""
# Read and store the function parameters
self.scene = scene
self.__ambient = ambient
self.__hardness = hardness
# By default, mark every object as textured.
self.flagTexturedObject(self.scene)
# Create the buffer plus a texture to store the output in
buffer = createOffscreenBuffer(-3)
depthmap = Texture()
buffer.addRenderTexture(depthmap, GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPColor)
# Set the shadow filter if it is supported
if (base.win.getGsg().getSupportsShadowFilter()):
depthmap.setMinfilter(Texture.FTShadow)
depthmap.setMagfilter(Texture.FTShadow)
# Make the camera
self.light = base.makeCamera(buffer)
self.light.node().setScene(self.scene)
self.light.node().getLens().setFov(fov)
self.light.node().getLens().setNearFar(near, far)
# Put a shader on the Light camera.
lci = NodePath(PandaNode("lightCameraInitializer"))
lci.setShader(loader.loadShader("caster.sha"))
self.light.node().setInitialState(lci.getState())
# Put a shader on the Main camera.
mci = NodePath(PandaNode("mainCameraInitializer"))
mci.setShader(loader.loadShader("softshadow.sha"))
base.cam.node().setInitialState(mci.getState())
# Set up the blurring buffers, one that blurs horizontally, the other vertically
#blurXBuffer = makeFilterBuffer(buffer, "Blur X", -2, loader.loadShader("blurx.sha"))
#blurYBuffer = makeFilterBuffer(blurXBuffer, "Blur Y", -1, loader.loadShader("blury.sha"))
# Set the shader inputs
self.scene.setShaderInput("light", self.light)
#self.scene.setShaderInput("depthmap", blurYBuffer.getTexture())
self.scene.setShaderInput("depthmap", buffer.getTexture())
self.scene.setShaderInput("props", ambient, hardness, 0, 1)
def __init__(self, scene=base.render, ambient=0.2, hardness=16, fov=40, near=10, far=100):
"""Create an instance of this class to initiate shadows.
Also, a shadow casting 'light' is created when this class is called.
The first parameter is the nodepath in the scene where you
want to apply your shadows on, by default this is render."""
# Read and store the function parameters
self.scene = scene
self.__ambient = ambient
self.__hardness = hardness
# By default, mark every object as textured.
self.flagTexturedObject(self.scene)
# Create the buffer plus a texture to store the output in
buffer = createOffscreenBuffer(-3)
depthmap = Texture()
buffer.addRenderTexture(depthmap, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
# Set the shadow filter if it is supported
if base.win.getGsg().getSupportsShadowFilter():
depthmap.setMinfilter(Texture.FTShadow)
depthmap.setMagfilter(Texture.FTShadow)
# Make the camera
self.light = base.makeCamera(buffer)
self.light.node().setScene(self.scene)
self.light.node().getLens().setFov(fov)
self.light.node().getLens().setNearFar(near, far)
# Put a shader on the Light camera.
lci = NodePath(PandaNode("lightCameraInitializer"))
lci.setShader(loader.loadShader("caster.sha"))
self.light.node().setInitialState(lci.getState())
# Put a shader on the Main camera.
mci = NodePath(PandaNode("mainCameraInitializer"))
mci.setShader(loader.loadShader("softshadow.sha"))
base.cam.node().setInitialState(mci.getState())
# Set up the blurring buffers, one that blurs horizontally, the other vertically
# blurXBuffer = makeFilterBuffer(buffer, "Blur X", -2, loader.loadShader("blurx.sha"))
# blurYBuffer = makeFilterBuffer(blurXBuffer, "Blur Y", -1, loader.loadShader("blury.sha"))
# Set the shader inputs
self.scene.setShaderInput("light", self.light)
# self.scene.setShaderInput("depthmap", blurYBuffer.getTexture())
self.scene.setShaderInput("depthmap", buffer.getTexture())
self.scene.setShaderInput("props", ambient, hardness, 0, 1)
class PandaHandler(DirectObject):
def __init__(self):
DirectObject.__init__(self)
# base.disableMouse()
# base.cam.setPos(0, -28, 6)
self.testModel = loader.loadModel('panda')
self.testModel.reparentTo(render)
# print self.testModel.getPos()
self.rotateInterval = LerpHprInterval(self.testModel, 3, Point3(360, 0, 0))
self.rotateInterval.loop()
self.screenTexture = Texture()
self.screenTexture.setMinfilter(Texture.FTLinear)
base.win.addRenderTexture(self.screenTexture, GraphicsOutput.RTMCopyRam)
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 Sprite2d:
class Cell:
def __init__(self, col, row):
self.col = col
self.row = row
def __str__(self):
return "Cell - Col %d, Row %d" % (self.col, self.row)
class Animation:
def __init__(self, cells, fps):
self.cells = cells
self.fps = fps
self.playhead = 0
ALIGN_CENTER = "Center"
ALIGN_LEFT = "Left"
ALIGN_RIGHT = "Right"
ALIGN_BOTTOM = "Bottom"
ALIGN_TOP = "Top"
TRANS_ALPHA = TransparencyAttrib.MAlpha
TRANS_DUAL = TransparencyAttrib.MDual
# One pixel is divided by this much. If you load a 100x50 image with PIXEL_SCALE of 10.0
# you get a card that is 1 unit wide, 0.5 units high
PIXEL_SCALE = 20.0
def __init__(self, image_path, rowPerFace, name=None,\
rows=1, cols=1, scale=1.0,\
twoSided=False, alpha=TRANS_ALPHA,\
repeatX=1, repeatY=1,\
anchorX=ALIGN_CENTER, anchorY=ALIGN_BOTTOM):
"""
Create a card textured with an image. The card is sized so that the ratio between the
card and image is the same.
"""
global SpriteId
self.spriteNum = str(SpriteId)
SpriteId += 1
scale *= self.PIXEL_SCALE
self.animations = {}
self.scale = scale
self.repeatX = repeatX
self.repeatY = repeatY
self.flip = {'x': False, 'y': False}
self.rows = rows
self.cols = cols
self.currentFrame = 0
self.currentAnim = None
self.loopAnim = False
self.frameInterrupt = True
# Create the NodePath
if name:
self.node = NodePath("Sprite2d:%s" % name)
else:
self.node = NodePath("Sprite2d:%s" % image_path)
# Set the attribute for transparency/twosided
self.node.node().setAttrib(TransparencyAttrib.make(alpha))
if twoSided:
self.node.setTwoSided(True)
# Make a filepath
self.imgFile = Filename(image_path)
if self.imgFile.empty():
raise IOError, "File not found"
# Instead of loading it outright, check with the PNMImageHeader if we can open
# the file.
imgHead = PNMImageHeader()
if not imgHead.readHeader(self.imgFile):
raise IOError, "PNMImageHeader could not read file. Try using absolute filepaths"
# Load the image with a PNMImage
image = PNMImage()
image.read(self.imgFile)
self.sizeX = image.getXSize()
self.sizeY = image.getYSize()
# We need to find the power of two size for the another PNMImage
# so that the texture thats loaded on the geometry won't have artifacts
textureSizeX = self.nextsize(self.sizeX)
textureSizeY = self.nextsize(self.sizeY)
# The actual size of the texture in memory
self.realSizeX = textureSizeX
self.realSizeY = textureSizeY
self.paddedImg = PNMImage(textureSizeX, textureSizeY)
if image.hasAlpha():
self.paddedImg.alphaFill(0)
# Copy the source image to the image we're actually using
self.paddedImg.blendSubImage(image, 0, 0)
# We're done with source image, clear it
image.clear()
# The pixel sizes for each cell
self.colSize = self.sizeX / self.cols
self.rowSize = self.sizeY / self.rows
# How much padding the texture has
self.paddingX = textureSizeX - self.sizeX
self.paddingY = textureSizeY - self.sizeY
# Set UV padding
self.uPad = float(self.paddingX) / textureSizeX
self.vPad = float(self.paddingY) / textureSizeY
# The UV dimensions for each cell
self.uSize = (1.0 - self.uPad) / self.cols
self.vSize = (1.0 - self.vPad) / self.rows
self.cards = []
self.rowPerFace = rowPerFace
for i in range(len(rowPerFace)):
card = CardMaker("Sprite2d-Geom")
# The positions to create the card at
if anchorX == self.ALIGN_LEFT:
posLeft = 0
posRight = (self.colSize / scale) * repeatX
elif anchorX == self.ALIGN_CENTER:
posLeft = -(self.colSize / 2.0 / scale) * repeatX
posRight = (self.colSize / 2.0 / scale) * repeatX
elif anchorX == self.ALIGN_RIGHT:
posLeft = -(self.colSize / scale) * repeatX
posRight = 0
if anchorY == self.ALIGN_BOTTOM:
posTop = 0
posBottom = (self.rowSize / scale) * repeatY
elif anchorY == self.ALIGN_CENTER:
posTop = -(self.rowSize / 2.0 / scale) * repeatY
posBottom = (self.rowSize / 2.0 / scale) * repeatY
elif anchorY == self.ALIGN_TOP:
posTop = -(self.rowSize / scale) * repeatY
posBottom = 0
card.setFrame(posLeft, posRight, posTop, posBottom)
card.setHasUvs(True)
self.cards.append(self.node.attachNewNode(card.generate()))
self.cards[-1].setH(i * 360 / len(rowPerFace))
# Since the texture is padded, we need to set up offsets and scales to make
# the texture fit the whole card
self.offsetX = (float(self.colSize) / textureSizeX)
self.offsetY = (float(self.rowSize) / textureSizeY)
# self.node.setTexScale(TextureStage.getDefault(), self.offsetX * repeatX, self.offsetY * repeatY)
# self.node.setTexOffset(TextureStage.getDefault(), 0, 1-self.offsetY)
self.texture = Texture()
self.texture.setXSize(textureSizeX)
self.texture.setYSize(textureSizeY)
self.texture.setZSize(1)
# Load the padded PNMImage to the texture
self.texture.load(self.paddedImg)
self.texture.setMagfilter(Texture.FTNearest)
self.texture.setMinfilter(Texture.FTNearest)
#Set up texture clamps according to repeats
if repeatX > 1:
self.texture.setWrapU(Texture.WMRepeat)
else:
self.texture.setWrapU(Texture.WMClamp)
if repeatY > 1:
self.texture.setWrapV(Texture.WMRepeat)
else:
self.texture.setWrapV(Texture.WMClamp)
self.node.setTexture(self.texture)
self.setFrame(0)
def nextsize(self, num):
""" Finds the next power of two size for the given integer. """
p2x = max(1, log(num, 2))
notP2X = modf(p2x)[0] > 0
return 2**int(notP2X + p2x)
def setFrame(self, frame=0):
""" Sets the current sprite to the given frame """
self.frameInterrupt = True # A flag to tell the animation task to shut it up ur face
self.currentFrame = frame
self.flipTexture()
def playAnim(self, animName, loop=False):
""" Sets the sprite to animate the given named animation. Booleon to loop animation"""
if not taskMgr.hasTaskNamed("Animate sprite" + self.spriteNum):
if hasattr(self, "task"):
taskMgr.remove("Animate sprite" + self.spriteNum)
del self.task
self.frameInterrupt = False # Clear any previous interrupt flags
self.loopAnim = loop
self.currentAnim = self.animations[animName]
self.currentAnim.playhead = 0
self.task = taskMgr.doMethodLater(
1.0 / self.currentAnim.fps, self.animPlayer,
"Animate sprite" + self.spriteNum)
def createAnim(self, animName, frameCols, fps=12):
""" Create a named animation. Takes the animation name and a tuple of frame numbers """
self.animations[animName] = Sprite2d.Animation(frameCols, fps)
return self.animations[animName]
def flipX(self, val=None):
""" Flip the sprite on X. If no value given, it will invert the current flipping."""
if val:
self.flip['x'] = val
else:
if self.flip['x']:
self.flip['x'] = False
else:
self.flip['x'] = True
self.flipTexture()
return self.flip['x']
def flipY(self, val=None):
""" See flipX """
if val:
self.flip['y'] = val
else:
if self.flip['y']:
self.flip['y'] = False
else:
self.flip['y'] = True
self.flipTexture()
return self.flip['y']
def updateCameraAngle(self, cameraNode):
baseH = cameraNode.getH(render) - self.node.getH(render)
degreesBetweenCards = 360 / len(self.cards)
bestCard = int(
((baseH) + degreesBetweenCards / 2) % 360 / degreesBetweenCards)
#print baseH, bestCard
for i in range(len(self.cards)):
if i == bestCard:
self.cards[i].show()
else:
self.cards[i].hide()
def flipTexture(self):
""" Sets the texture coordinates of the texture to the current frame"""
for i in range(len(self.cards)):
currentRow = self.rowPerFace[i]
sU = self.offsetX * self.repeatX
sV = self.offsetY * self.repeatY
oU = 0 + self.currentFrame * self.uSize
#oU = 0 + self.frames[self.currentFrame].col * self.uSize
#oV = 1 - self.frames[self.currentFrame].row * self.vSize - self.offsetY
oV = 1 - currentRow * self.vSize - self.offsetY
if self.flip['x'] ^ i == 1: ##hack to fix side view
#print "flipping, i = ",i
sU *= -1
#oU = self.uSize + self.frames[self.currentFrame].col * self.uSize
oU = self.uSize + self.currentFrame * self.uSize
if self.flip['y']:
sV *= -1
#oV = 1 - self.frames[self.currentFrame].row * self.vSize
oV = 1 - currentRow * self.vSize
self.cards[i].setTexScale(TextureStage.getDefault(), sU, sV)
self.cards[i].setTexOffset(TextureStage.getDefault(), oU, oV)
def clear(self):
""" Free up the texture memory being used """
self.texture.clear()
self.paddedImg.clear()
self.node.removeNode()
def animPlayer(self, task):
if self.frameInterrupt:
return task.done
#print "Playing",self.currentAnim.cells[self.currentAnim.playhead]
self.currentFrame = self.currentAnim.cells[self.currentAnim.playhead]
self.flipTexture()
if self.currentAnim.playhead + 1 < len(self.currentAnim.cells):
self.currentAnim.playhead += 1
return task.again
if self.loopAnim:
self.currentAnim.playhead = 0
return task.again
class MazeMapGui(DirectFrame):
__module__ = __name__
notify = directNotify.newCategory('MazeMapGui')
def __init__(self,
mazeCollTable,
maskResolution=None,
radiusRatio=None,
bgColor=(0.8, 0.8, 0.8),
fgColor=(0.5, 0.5, 0.5, 1.0)):
DirectFrame.__init__(self,
relief=None,
state=DGG.NORMAL,
sortOrder=DGG.BACKGROUND_SORT_INDEX)
self.hide()
self._bgColor = bgColor
self._fgColor = fgColor
self._mazeCollTable = mazeCollTable
self._mazeWidth = len(self._mazeCollTable[0])
self._mazeHeight = len(self._mazeCollTable)
if not maskResolution:
self._maskResolution = DEFAULT_MASK_RESOLUTION
self._radius = radiusRatio is None and self._maskResolution * DEFAULT_RADIUS_RATIO
else:
self._radius = self._maskResolution * radiusRatio
self._revealedCells = []
for y in range(self._mazeHeight):
self._revealedCells.append([])
for u in range(self._mazeWidth):
self._revealedCells[y].append(False)
self._revealFunctions = {
MazeRevealType.SmoothCircle: self._revealSmoothCircle,
MazeRevealType.HardCircle: self._revealHardCircle,
MazeRevealType.Square: self._revealSquare
}
self._revealFunction = MAZE_REVEAL_TYPE
self.map = self._createMapTextureCard()
self.map.reparentTo(self)
self.maskedLayer = self.attachNewNode('maskedLayer')
self.mask = self._createMaskTextureCard()
self.mask.reparentTo(self)
self.visibleLayer = self.attachNewNode('visibleLayer')
self._laffMeterModel = loader.loadModel(
'phase_3/models/gui/laff_o_meter')
self._toon2marker = {}
return
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 _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 _drawSquare(self, image, ulx, uly, size, color):
x = int(ulx)
while x <= ulx + size:
y = int(uly)
while y <= uly + size:
if x > 0 and y > 0 and x < image.getXSize(
) and y < image.getYSize():
image.setXelA(x, y, color)
y += 1
x += 1
def destroy(self):
del self._mazeCollTable
del self._maskResolution
del self._radius
del self._revealedCells
del self._revealFunctions
del self._revealFunction
self.map.removeNode()
del self.map
self.mask.removeNode()
del self.mask
self.maskedLayer.removeNode()
del self.maskedLayer
self.visibleLayer.removeNode()
del self.visibleLayer
self._maskImage.clear()
del self._maskImage
self.maskTexture.clear()
del self.maskTexture
self._laffMeterModel.removeNode()
del self._laffMeterModel
DirectFrame.destroy(self)
def _revealSmoothCircle(self, x, y, center):
length = (Vec2(x, y) - center).length()
goalAlpha = max(0.0, length / float(self._radius) - 0.5)
self._maskImage.setXelA(
x, y,
VBase4D(0.0, 0.0, 0.0,
min(self._maskImage.getAlpha(x, y), goalAlpha * 2.0)))
def _revealHardCircle(self, x, y, center):
length = (Vec2(x, y) - center).length()
if length <= self._radius:
self._maskImage.setXelA(x, y, VBase4D(0, 0, 0, 0))
def _revealSquare(self, x, y, center):
self._maskImage.setXelA(x, y, VBase4D(0, 0, 0, 0))
def _drawHole(self, x, y):
center = Vec2(x, y)
ul = center - Vec2(self._radius, self._radius)
lr = center + Vec2(self._radius, self._radius)
x = int(ul[0])
while x <= lr[0]:
y = int(ul[1])
while y <= lr[1]:
if x > 0 and y > 0 and x < self._maskResolution and y < self._maskResolution:
self._revealFunctions[self._revealFunction](x, y, center)
y += 1
x += 1
self.maskTexture.load(self._maskImage)
self.mask.setTexture(self.maskTexture, 1)
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 tile2gui(self, x, y):
y = self._mazeHeight - y
cellWidth = self._maskResolution / self._mazeWidth
cellHeight = self._maskResolution / self._mazeHeight
ax = float(x) / self._mazeWidth * self._maskResolution
ax += cellWidth
ay = float(y) / self._mazeHeight * self._maskResolution
ay += cellHeight
return (ax, ay)
def gui2pos(self, x, y):
return (x / self._maskResolution * 2.0 - 0.97, 0,
y / self._maskResolution * -2.0 + 1.02)
def _getToonMarker(self, toon):
hType = toon.style.getType()
if hType == 'rabbit':
hType = 'bunny'
return self._laffMeterModel.find('**/' + hType + 'head')
def addToon(self, toon, tX, tY):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(0.07)
else:
marker.setScale(0.05)
marker.flattenStrong()
marker.setPos(*self.gui2pos(*self.tile2gui(tX, tY)))
self._toon2marker[toon] = marker
def removeToon(self, toon):
if not self._toon2marker.has_key(toon):
return
self._toon2marker[toon].removeNode()
del self._toon2marker[toon]
def updateToon(self, toon, tX, tY):
if not self._toon2marker.has_key(toon):
return
x, y = self.tile2gui(tX, tY)
self._toon2marker[toon].setPos(*self.gui2pos(x, y))
if tY < 0 or tY >= len(self._revealedCells):
self.notify.warning('updateToon earlying out:')
self.notify.warning('(tX, tY): (%s, %s)' % (tX, tY))
self.notify.warning('len(_revealedCells): %s' %
(len(self._revealedCells), ))
if len(self._revealedCells) > 0:
self.notify.warning('len(_revealedCells[0]): %s' %
(len(self._revealedCells[0]), ))
return
if tX < 0 or tX >= len(self._revealedCells[tY]):
self.notify.warning('updateToon earlying out:')
self.notify.warning('(tX, tY): (%s, %s)' % (tX, tY))
self.notify.warning('len(_revealedCells): %s' %
(len(self._revealedCells), ))
if tY < len(self._revealedCells):
self.notify.warning('len(_revealedCells[tY]): %s' %
(len(self._revealedCells[tY]), ))
elif len(self._revealedCells) > 0:
self.notify.warning('len(_revealedCells[0]): %s' %
(len(self._revealedCells[0]), ))
return
if not self._revealedCells[tY][tX]:
self._drawHole(x, y)
self._revealedCells[tY][tX] = True
def revealCell(self, x, y):
ax, ay = self.tile2gui(x, y)
if not self._revealedCells[y][x]:
self._drawHole(ax, ay)
self._revealedCells[y][x] = True
def revealAll(self):
for x in range(self._maskResolution):
for y in range(self._maskResolution):
self._maskImage.setXelA(x, y, 0, 0, 0, 0)
self.revealCell(0, 0)
def reset(self):
for x in range(self._maskResolution):
for y in range(self._maskResolution):
self._maskImage.setXelA(x, y, 0, 0, 0, 1)
class Effect:
baseWidth = 0
baseHeight = 0
effectWidth = 1
effectHeight = 1
effectTargetMS = 143
noSampling = False
tex = None
loadedFormat = None
# Animation variables
internalFrameIndex = 1
startIndex = 1
endIndex = 1
loopEffect = False
# XML variables
tree = None
frames = None
colors = None
tweens = None
compositeFrames = None
# Nodes
consumedNodesList = None
# Accessible object (nodePath)
effectCameraNodePath = None
effectCardNodePath = None
# Constant value; Unit comparison for card size; basis is from cure, which is [140x110]
cardDimensionBasis = [-5.0, 5.0, 0.0, 10.0, 140.0, 110.0]
pixelScaleX = cardDimensionBasis[4] / (cardDimensionBasis[1] - cardDimensionBasis[0])
pixelScaleZ = cardDimensionBasis[5] / (cardDimensionBasis[3] - cardDimensionBasis[2])
effectIsCentered = True
effectAdjustment = [0, 0, 0]
def __init__(self, effectFileName, parent=None, loop=False, effectIsCentered=True, effectAdjustment=[0, 0, 0]):
self.effectAdjustment = effectAdjustment
self.loopEffect = loop
self.effectIsCentered = effectIsCentered
self.loadedFormat = None
if effectFileName != None:
effectFileNameSplit = effectFileName.split(".")
self.loadedFormat = effectFileNameSplit[len(effectFileNameSplit) - 2] # Get value at penultimate index
if self.loadedFormat == effectFileNameSplit[0]:
self.loadedFormat = None # Get rid of bad format name.
pass
# Load texture; supply alpha channel if it doesn't exist.
p = transparencyKey(effectFileName)
self.tex = Texture()
self.tex.setup2dTexture(p.getXSize(), p.getYSize(), Texture.TUnsignedByte, Texture.FRgba)
self.tex.load(p)
if self.loadedFormat != None:
try:
self.tree = etree.parse("./" + GAME + "/effects/" + self.loadedFormat + "/sprite.xml")
except IOError:
self.loadedFormat = None
pass
if self.loadedFormat != None:
root = self.tree.getroot()
self.frames = root.find(".//frames")
self.colors = root.find(".//colors")
self.tweens = root.find(".//motion-tweens")
self.compositeFrames = root.find(".//composite-frames")
self.baseWidth = 0 if root.attrib.get("base-width") == None else float(root.attrib.get("base-width"))
self.baseHeight = 0 if root.attrib.get("base-height") == None else float(root.attrib.get("base-height"))
self.effectWidth = 1 if root.attrib.get("frame-width") == None else float(root.attrib.get("frame-width"))
self.effectHeight = 1 if root.attrib.get("frame-height") == None else float(root.attrib.get("frame-height"))
self.effectTargetMS = 143 if root.attrib.get("target-ms") == None else float(root.attrib.get("target-ms"))
self.startIndex = 1 if root.attrib.get("target-start") == None else int(root.attrib.get("target-start"))
self.endIndex = 1 if root.attrib.get("target-end") == None else int(root.attrib.get("target-end"))
self.noSampling = False if root.attrib.get("no-sampling") == None else bool(root.attrib.get("no-sampling"))
if self.noSampling == True:
self.tex.setMagfilter(Texture.FTNearest)
self.tex.setMinfilter(Texture.FTNearest)
cm = CardMaker("card-" + effectFileName)
cardDeltaX = self.effectWidth / self.pixelScaleX
cardDeltaZ = self.effectHeight / self.pixelScaleZ
if self.effectIsCentered == True:
cm.setFrame(0, 0, 0, 0)
deltaX = (cardDeltaX / 2.0) - (-cardDeltaX / 2.0)
deltaY = 0
deltaZ = (cardDeltaZ / 2.0) - (-cardDeltaZ / 2.0)
# occluder = OccluderNode('effect-parent-occluder', Point3((-cardDeltaX/2.0), 0, (-cardDeltaZ/2.0)), Point3((-cardDeltaX/2.0), 0, (cardDeltaZ/2.0)), Point3((cardDeltaX/2.0), 0, (cardDeltaZ/2.0)), Point3((cardDeltaX/2.0), 0, (-cardDeltaZ/2.0)))
else:
cm.setFrame(0, 0, 0, 0)
deltaX = (cardDeltaX / 2.0) - (-cardDeltaX / 2.0)
deltaY = 0
deltaZ = cardDeltaZ - 0
# occluder = OccluderNode('effect-parent-occluder', Point3((-cardDeltaX/2.0), 0, 0), Point3((-cardDeltaX/2.0), 0, cardDeltaZ), Point3((cardDeltaX/2.0), 0, cardDeltaZ), Point3((cardDeltaX/2.0), 0, 0))
self.effectCardNodePath = render.attachNewNode(cm.generate())
self.effectCardNodePath.setBillboardPointEye()
self.effectCardNodePath.reparentTo(parent)
# occluder_nodepath = self.effectCardNodePath.attachNewNode(occluder)
# self.effectCardNodePath.setOccluder(occluder_nodepath)
emptyNode = NodePath("effect-parent-translator")
emptyNode.reparentTo(self.effectCardNodePath)
if effectIsCentered == True:
emptyNode.setPos(
-deltaX / 2.0 + self.effectAdjustment[0],
0 + self.effectAdjustment[1],
deltaZ / 2.0 + self.effectAdjustment[2],
)
else:
emptyNode.setPos(
-deltaX / 2.0 + self.effectAdjustment[0],
0 + self.effectAdjustment[1],
deltaZ + self.effectAdjustment[2],
)
# emptyNode.place()
emptyNode.setSx(float(deltaX) / self.effectWidth)
emptyNode.setSz(float(deltaZ) / self.effectHeight)
self.effectCameraNodePath = emptyNode
if parent != None:
self.effectCardNodePath.reparentTo(parent)
else:
self.effectCardNodePath.reparentTo(render)
# self.effectCardNodePath.place()
self.effectCardNodePath.setBin("fixed", 40)
self.effectCardNodePath.setDepthTest(False)
self.effectCardNodePath.setDepthWrite(False)
pass
def getSequence(self):
sequence = Sequence()
for x in range(self.startIndex, self.endIndex, 1):
sequence.append(Func(self.pandaRender))
sequence.append(Func(self.advanceFrame))
sequence.append(Wait(self.effectTargetMS * 0.001))
sequence.append(Func(self.clearNodesForDrawing))
sequence.append(Func(self.advanceFrame))
sequence.append(Wait(self.effectTargetMS * 0.001))
return sequence
pass
def hasEffectFinished(self):
if self.internalFrameIndex > self.endIndex and self.loopEffect == False:
return True
else:
return False
pass
def advanceFrame(self):
if self.internalFrameIndex < self.endIndex:
self.internalFrameIndex += 1
elif self.internalFrameIndex == self.endIndex and self.loopEffect == True:
self.internalFrameIndex = self.startIndex
else:
self.internalFrameIndex = self.endIndex + 1
self.clearNodesForDrawing()
pass
def clearNodesForDrawing(self):
if False:
self.effectCameraNodePath.analyze()
if self.consumedNodesList != None and self.consumedNodesList != []:
for consumedNode in self.consumedNodesList:
consumedNode.removeNode()
self.consumedNodesList = []
pass
def pandaRender(self):
frameList = []
for node in self.compositeFrames.getiterator("composite-frame"):
if node.tag == "composite-frame" and node.attrib.get("id") == str(self.internalFrameIndex):
for frameCallNode in node:
for frameNode in self.frames.getiterator("frame"):
if frameNode.tag == "frame" and frameNode.attrib.get("id") == frameCallNode.attrib.get("id"):
offsetX = (
0
if frameCallNode.attrib.get("offset-x") == None
else float(frameCallNode.attrib.get("offset-x"))
)
offsetY = (
0
if frameCallNode.attrib.get("offset-y") == None
else float(frameCallNode.attrib.get("offset-y"))
)
tweenId = frameCallNode.attrib.get("tween")
frameInTween = (
0
if frameCallNode.attrib.get("frame-in-tween") == None
else int(frameCallNode.attrib.get("frame-in-tween"))
)
addWidth = 0 if frameNode.attrib.get("w") == None else float(frameNode.attrib.get("w"))
addHeight = 0 if frameNode.attrib.get("h") == None else float(frameNode.attrib.get("h"))
sInPixels = 0 if frameNode.attrib.get("s") == None else float(frameNode.attrib.get("s"))
tInPixels = 0 if frameNode.attrib.get("t") == None else float(frameNode.attrib.get("t"))
swInPixels = sInPixels + addWidth
thInPixels = tInPixels + addHeight
s = sInPixels / self.baseWidth
t = 1 - (
tInPixels / self.baseHeight
) # Complemented to deal with loading image upside down.
S = swInPixels / self.baseWidth
T = 1 - (
thInPixels / self.baseHeight
) # Complemented to deal with loading image upside down.
blend = (
"overwrite"
if frameCallNode.attrib.get("blend") == None
else frameCallNode.attrib.get("blend")
)
scaleX = (
1
if frameCallNode.attrib.get("scale-x") == None
else float(frameCallNode.attrib.get("scale-x"))
)
scaleY = (
1
if frameCallNode.attrib.get("scale-y") == None
else float(frameCallNode.attrib.get("scale-y"))
)
color = Color(1, 1, 1, 1)
tweenHasColor = False
frameCallHasColor = False
frameCallColorName = frameCallNode.attrib.get("color-name")
if frameCallColorName != None:
# Get color at frame call as first resort.
frameCallHasColor = True
for colorNode in self.colors.getiterator("color"):
if colorNode.tag == "color" and colorNode.attrib.get("name") == frameCallColorName:
R = 1 if colorNode.attrib.get("r") == None else float(colorNode.attrib.get("r"))
G = 1 if colorNode.attrib.get("g") == None else float(colorNode.attrib.get("g"))
B = 1 if colorNode.attrib.get("b") == None else float(colorNode.attrib.get("b"))
A = 1 if colorNode.attrib.get("a") == None else float(colorNode.attrib.get("a"))
color = Color(R, G, B, A)
break # leave for loop when we find the correct color
pass
if tweenId != None and tweenId != "0":
# Get color at tween frame as second resort.
thisTween = None
frameLength = 1
advancementFunction = "linear"
foundTween = False
pointList = []
colorList = []
for tweenNode in self.tweens.getiterator("motion-tween"):
if tweenNode.tag == "motion-tween" and tweenNode.attrib.get("id") == tweenId:
foundTween = True
frameLength = (
1
if tweenNode.attrib.get("length-in-frames") == None
else tweenNode.attrib.get("length-in-frames")
)
advancementFunction = (
"linear"
if tweenNode.attrib.get("advancement-function") == None
else tweenNode.attrib.get("advancement-function")
)
for pointOrColorNode in tweenNode.getiterator():
if pointOrColorNode.tag == "point":
pX = (
0
if pointOrColorNode.attrib.get("x") == None
else float(pointOrColorNode.attrib.get("x"))
)
pY = (
0
if pointOrColorNode.attrib.get("y") == None
else float(pointOrColorNode.attrib.get("y"))
)
pointList.append(Point(pX, pY, 0))
elif pointOrColorNode.tag == "color-state":
colorName = (
"white"
if pointOrColorNode.attrib.get("name") == None
else pointOrColorNode.attrib.get("name")
)
for colorNode in self.colors.getiterator("color"):
if (
colorNode.tag == "color"
and colorNode.attrib.get("name") == colorName
):
R = (
1
if colorNode.attrib.get("r") == None
else float(colorNode.attrib.get("r"))
)
G = (
1
if colorNode.attrib.get("g") == None
else float(colorNode.attrib.get("g"))
)
B = (
1
if colorNode.attrib.get("b") == None
else float(colorNode.attrib.get("b"))
)
A = (
1
if colorNode.attrib.get("a") == None
else float(colorNode.attrib.get("a"))
)
colorList.append(Color(R, G, B, A))
break # leave for loop when we find the correct color reference
pass # Run through all child nodes of selected tween
break # Exit after finding correct tween
pass
if foundTween:
thisTween = Tween(frameLength, advancementFunction, pointList, colorList)
offset = thisTween.XYFromFrame(frameInTween)
offsetFromTweenX = int(offset.X)
offsetFromTweenY = int(offset.Y)
offsetX += int(offset.X)
offsetY += int(offset.Y)
if thisTween.hasColorComponent():
tweenHasColor = True
if frameCallHasColor == False:
color = thisTween.colorFromFrame(frameInTween)
pass
if (
frameNode.attrib.get("color-name") != None
and frameCallHasColor == False
and tweenHasColor == False
):
# Get color at frame definition as last resort.
for colorNode in colors.getiterator("color"):
if colorNode.tag == "color" and colorNode.attrib.get(
"name"
) == frameNode.attrib.get("color-name"):
R = 1 if colorNode.attrib.get("r") == None else float(colorNode.attrib.get("r"))
G = 1 if colorNode.attrib.get("g") == None else float(colorNode.attrib.get("g"))
B = 1 if colorNode.attrib.get("b") == None else float(colorNode.attrib.get("b"))
A = 1 if colorNode.attrib.get("a") == None else float(colorNode.attrib.get("a"))
color = Color(R, G, B, A)
break # leave for loop when we find the correct color
pass
rotationZ = (
0
if frameCallNode.attrib.get("rotation-z") == None
else float(frameCallNode.attrib.get("rotation-z"))
)
frameList.append(
Frame(
Bound(offsetX, offsetY, addWidth, addHeight),
s,
t,
S,
T,
blend,
scaleX,
scaleY,
color,
rotationZ,
)
)
pass
break # Leave once we've found the appropriate frame
# Prepare tracking list of consumed nodes.
self.clearNodesForDrawing()
# Make an identifier to tack onto primitive names in Panda3d's scene graph.
frameIndexForName = 1
# Loop through loaded frames that make up composite frame.
for loadedFrame in frameList:
# For debugging purposes, print the object.
if False:
loadedFrame.printAsString()
# Set up place to store primitive 3d object; note: requires vertex data made by GeomVertexData
squareMadeByTriangleStrips = GeomTristrips(Geom.UHDynamic)
# Set up place to hold 3d data and for the following coordinates:
# square's points (V3: x, y, z),
# the colors at each point of the square (c4: r, g, b, a), and
# for the UV texture coordinates at each point of the square (t2: S, T).
vertexData = GeomVertexData(
"square-" + str(frameIndexForName), GeomVertexFormat.getV3c4t2(), Geom.UHDynamic
)
vertex = GeomVertexWriter(vertexData, "vertex")
color = GeomVertexWriter(vertexData, "color")
texcoord = GeomVertexWriter(vertexData, "texcoord")
# Add the square's data
# Upper-Left corner of square
vertex.addData3f(-loadedFrame.bound.Width / 2.0, 0, -loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R, loadedFrame.color.G, loadedFrame.color.B, loadedFrame.color.A)
texcoord.addData2f(loadedFrame.s, loadedFrame.T)
# Upper-Right corner of square
vertex.addData3f(loadedFrame.bound.Width / 2.0, 0, -loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R, loadedFrame.color.G, loadedFrame.color.B, loadedFrame.color.A)
texcoord.addData2f(loadedFrame.S, loadedFrame.T)
# Lower-Left corner of square
vertex.addData3f(-loadedFrame.bound.Width / 2.0, 0, loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R, loadedFrame.color.G, loadedFrame.color.B, loadedFrame.color.A)
texcoord.addData2f(loadedFrame.s, loadedFrame.t)
# Lower-Right corner of square
vertex.addData3f(loadedFrame.bound.Width / 2.0, 0, loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R, loadedFrame.color.G, loadedFrame.color.B, loadedFrame.color.A)
texcoord.addData2f(loadedFrame.S, loadedFrame.t)
# Pass data to primitive
squareMadeByTriangleStrips.addNextVertices(4)
squareMadeByTriangleStrips.closePrimitive()
square = Geom(vertexData)
square.addPrimitive(squareMadeByTriangleStrips)
# Pass primtive to drawing node
drawPrimitiveNode = GeomNode("square-" + str(frameIndexForName))
drawPrimitiveNode.addGeom(square)
# Pass node to scene (effect camera)
nodePath = self.effectCameraNodePath.attachNewNode(drawPrimitiveNode)
# Linear dodge:
if loadedFrame.blendMode == "darken":
nodePath.setAttrib(
ColorBlendAttrib.make(
ColorBlendAttrib.MAdd,
ColorBlendAttrib.OOneMinusFbufferColor,
ColorBlendAttrib.OOneMinusIncomingColor,
)
)
pass
elif loadedFrame.blendMode == "multiply":
nodePath.setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OFbufferColor, ColorBlendAttrib.OZero)
)
pass
elif loadedFrame.blendMode == "color-burn":
nodePath.setAttrib(
ColorBlendAttrib.make(
ColorBlendAttrib.MAdd, ColorBlendAttrib.OZero, ColorBlendAttrib.OOneMinusIncomingColor
)
)
pass
elif loadedFrame.blendMode == "linear-burn":
nodePath.setAttrib(
ColorBlendAttrib.make(
ColorBlendAttrib.MAdd, ColorBlendAttrib.OZero, ColorBlendAttrib.OIncomingColor
)
)
pass
elif loadedFrame.blendMode == "lighten":
nodePath.setAttrib(
ColorBlendAttrib.make(
ColorBlendAttrib.MMax, ColorBlendAttrib.OIncomingColor, ColorBlendAttrib.OFbufferColor
)
)
pass
elif loadedFrame.blendMode == "color-dodge":
nodePath.setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOne)
)
pass
elif loadedFrame.blendMode == "linear-dodge":
nodePath.setAttrib(
ColorBlendAttrib.make(
ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOneMinusIncomingColor
)
)
pass
else: # Overwrite:
nodePath.setAttrib(
ColorBlendAttrib.make(
ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOneMinusIncomingAlpha
)
)
pass
nodePath.setDepthTest(False)
# Apply texture
nodePath.setTexture(self.tex)
# Apply translation, then rotation, then scaling to node.
nodePath.setPos(
(
loadedFrame.bound.X + loadedFrame.bound.Width / 2.0,
1,
-loadedFrame.bound.Y - loadedFrame.bound.Height / 2.0,
)
)
nodePath.setR(loadedFrame.rotationZ)
nodePath.setScale(loadedFrame.scaleX, 1, loadedFrame.scaleY)
nodePath.setTwoSided(True)
self.consumedNodesList.append(nodePath)
frameIndexForName = frameIndexForName + 1
# Loop continues on through each frame called in the composite frame.
pass
class MazeMapGui(DirectFrame):
notify = directNotify.newCategory("MazeMapGui")
def __init__(self, mazeLayout, maskResolution=None, radiusRatio=None):
"""
Constructor for a MazeMap. the mazeLayout parameter is a 2d array of
bools (or ints... maybe more depth will be added with that).
maskResolution is a value for the resolution of the mask covering the
map. It should range from 32 to 256. radiusRatio is essentially
the percentage of the map that is revealed with each step.
"""
DirectFrame.__init__(self,
relief = None,
state = DGG.NORMAL,
sortOrder = DGG.BACKGROUND_SORT_INDEX,
)
# store / set parameters
self._mazeLayout = mazeLayout
self._maskResolution = maskResolution or DEFAULT_MASK_RESOLUTION
if radiusRatio is None:
self._radius = self._maskResolution * DEFAULT_RADIUS_RATIO
else:
self._radius = self._maskResolution * radiusRatio
# store false for all maze cells to represent that none of them have
# been revealed yet. This can prevent the expensive call to altering
# the mask if a cell is already revealed
self._revealedCells = []
for y in range( len(self._mazeLayout) ):
self._revealedCells.append([])
for x in range( len(self._mazeLayout[0]) ):
self._revealedCells[y].append(False)
# create reveal function mappings
self._revealFunctions = {
MazeRevealType.SmoothCircle : self._revealSmoothCircle,
MazeRevealType.HardCircle : self._revealHardCircle,
MazeRevealType.Square : self._revealSquare,
}
self._revealFunction = MAZE_REVEAL_TYPE
# create the map and the mask
self.map = self._createMapTextureCard()
self.map.reparentTo(self)
self.maskedLayer = self.attachNewNode("maskedLayer")
self.mask = self._createMaskTextureCard()
self.mask.reparentTo(self)
self.visibleLayer = self.attachNewNode("visibleLayer")
#TODO:maze: handle locks and doors
self._players = []
self._locks = []
self._doors = []
#--- Initialization, Destruction, and Resetting ---#########################
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
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 _drawSquare(self, image, ulx, uly, size, color):
"""
Draws a square on the supplied PNMImage starting at (ulx, uly) with a
size of "size" and a color of "color".
"""
x = int(ulx)
while x <= ulx + size:
y = int(uly)
while y <= uly + size:
if x > 0 and y > 0 and x < image.getXSize() and y < image.getYSize():
image.setXelA( x, y, color )
y += 1
x += 1
def destroy(self):
del self._mazeLayout
del self._maskResolution
del self._radius
del self._revealedCells
del self._revealFunctions
del self._revealFunction
# remove and delete all nodes
self.map.removeNode()
del self.map
self.mask.removeNode()
del self.mask
self.maskedLayer.removeNode()
del self.maskedLayer
self.visibleLayer.removeNode()
del self.visibleLayer
# remove and delete all lists of nodes
for p in self._players:
p.removeNode()
del self._players
for k in self._locks:
k.removeNode()
del self._locks
for d in self._doors:
d.removeNode()
del self._doors
self._maskImage.clear()
del self._maskImage
self.maskTexture.clear()
del self.maskTexture
DirectFrame.destroy(self)
#--- Reveal shape functions ---#############################################
def _revealSmoothCircle(self, x, y, center):
length = (Vec2(x,y)-center).length()
goalAlpha = max(0.0, (length/float(self._radius)) - 0.5)
self._maskImage.setXelA(
x,
y,
VBase4D( 0.0, 0.0, 0.0, min(self._maskImage.getAlpha(x,y), goalAlpha*2.0))
)
def _revealHardCircle(self, x, y, center):
length = (Vec2(x,y)-center).length()
if length <= self._radius:
self._maskImage.setXelA(x,y,VBase4D(0,0,0,0))
def _revealSquare(self, x, y, center):
self._maskImage.setXelA(x,y,VBase4D(0,0,0,0))
#--- Private Functions ---##################################################
def _drawHole(self, x, y):
center = Vec2(x, y)
ul = center - Vec2(self._radius, self._radius)
lr = center + Vec2(self._radius, self._radius)
x = int(ul[0])
while x <= lr[0]:
y = int(ul[1])
while y <= lr[1]:
if x > 0 and y > 0 and x < self._maskResolution and y < self._maskResolution:
self._revealFunctions[self._revealFunction](x, y, center)
y += 1
x += 1
self.maskTexture.load(self._maskImage)
self.mask.setTexture(self.maskTexture, 1)
def _tileToActualPosition(self, x, y):
y = len(self._mazeLayout) - y
cellWidth = self._maskResolution / len(self._mazeLayout[0])
cellHeight = self._maskResolution / len(self._mazeLayout)
ax = float(x)/len(self._mazeLayout[0]) * self._maskResolution
ax += cellWidth
ay = float(y)/len(self._mazeLayout) * self._maskResolution
ay += cellHeight
return ax, ay
#--- Member Functions ---###################################################
def addDoor(self, x, y, color):
"""
Adds a door to the minimap. This will add a colored dot to the map
that represents a door.
--- 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 door model / texture
cm = CardMaker("door_cardMaker")
cm.setFrame(-0.04,0.04,-0.04,0.04)
#door = self.visibleLayer.attachNewNode(cm.generate())
door = self.maskedLayer.attachNewNode(cm.generate())
door.setColor(color)
door.setPos(x/self._maskResolution*2.0 - 0.97, 0, y/self._maskResolution*-2.0 + 1.02)
self._doors.append(door)
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 addPlayer(self, x, y, color):
"""
Adds a player to the minimap. This will add a colored dot to the map
that represents the player. The dot location can then be updated
using the revealCell call.
--- 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 player model / texture
cm = CardMaker("player_cardMaker")
cm.setFrame(-0.04,0.04,-0.04,0.04)
player = self.visibleLayer.attachNewNode(cm.generate())
player.setColor(color)
player.setPos(x/self._maskResolution*2.0 - 0.97, 0, y/self._maskResolution*-2.0 + 1.02)
self._players.append(player)
def revealCell(self, x, y, playerIndex=None):
"""
Clears out the mask around the given cell and stores that the cell has
been revealed to prevent attempting to edit the mask for the cell again.
"""
ax, ay = self._tileToActualPosition(x, y)
if not self._revealedCells[y][x]:
self._drawHole(ax, ay)
self._revealedCells[y][x] = True
if playerIndex is not None:
assert(playerIndex < len(self._players))
self._players[playerIndex].setPos(ax/self._maskResolution*2.0 - 0.97, 0, ay/self._maskResolution*-2.0 + 1.02)
def revealAll(self):
""" Clears out all of the mask. """
for x in range(self._maskResolution):
for y in range(self._maskResolution):
self._maskImage.setXelA(x,y,0,0,0,0)
def reset(self):
""" Turns all of the mask on, covering the entire map. """
for x in range(self._maskResolution):
for y in range(self._maskResolution):
self._maskImage.setXelA(x,y,0,0,0,1)
class Sprite2d:
class Cell:
def __init__(self, col, row):
self.col = col
self.row = row
def __str__(self):
return "Cell - Col %d, Row %d" % (self.col, self.row)
class Animation:
def __init__(self, cells, fps):
self.cells = cells
self.fps = fps
self.playhead = 0
ALIGN_CENTER = "Center"
ALIGN_LEFT = "Left"
ALIGN_RIGHT = "Right"
ALIGN_BOTTOM = "Bottom"
ALIGN_TOP = "Top"
TRANS_ALPHA = TransparencyAttrib.MAlpha
TRANS_DUAL = TransparencyAttrib.MDual
# One pixel is divided by this much. If you load a 100x50 image with PIXEL_SCALE of 10.0
# you get a card that is 1 unit wide, 0.5 units high
PIXEL_SCALE = 20.0
def __init__(self, image_path, rowPerFace, name=None,\
rows=1, cols=1, scale=1.0,\
twoSided=False, alpha=TRANS_ALPHA,\
repeatX=1, repeatY=1,\
anchorX=ALIGN_CENTER, anchorY=ALIGN_BOTTOM):
"""
Create a card textured with an image. The card is sized so that the ratio between the
card and image is the same.
"""
global SpriteId
self.spriteNum = str(SpriteId)
SpriteId += 1
scale *= self.PIXEL_SCALE
self.animations = {}
self.scale = scale
self.repeatX = repeatX
self.repeatY = repeatY
self.flip = {'x':False,'y':False}
self.rows = rows
self.cols = cols
self.currentFrame = 0
self.currentAnim = None
self.loopAnim = False
self.frameInterrupt = True
# Create the NodePath
if name:
self.node = NodePath("Sprite2d:%s" % name)
else:
self.node = NodePath("Sprite2d:%s" % image_path)
# Set the attribute for transparency/twosided
self.node.node().setAttrib(TransparencyAttrib.make(alpha))
if twoSided:
self.node.setTwoSided(True)
# Make a filepath
self.imgFile = Filename(image_path)
if self.imgFile.empty():
raise IOError, "File not found"
# Instead of loading it outright, check with the PNMImageHeader if we can open
# the file.
imgHead = PNMImageHeader()
if not imgHead.readHeader(self.imgFile):
raise IOError, "PNMImageHeader could not read file. Try using absolute filepaths"
# Load the image with a PNMImage
image = PNMImage()
image.read(self.imgFile)
self.sizeX = image.getXSize()
self.sizeY = image.getYSize()
# We need to find the power of two size for the another PNMImage
# so that the texture thats loaded on the geometry won't have artifacts
textureSizeX = self.nextsize(self.sizeX)
textureSizeY = self.nextsize(self.sizeY)
# The actual size of the texture in memory
self.realSizeX = textureSizeX
self.realSizeY = textureSizeY
self.paddedImg = PNMImage(textureSizeX, textureSizeY)
if image.hasAlpha():
self.paddedImg.alphaFill(0)
# Copy the source image to the image we're actually using
self.paddedImg.blendSubImage(image, 0, 0)
# We're done with source image, clear it
image.clear()
# The pixel sizes for each cell
self.colSize = self.sizeX/self.cols
self.rowSize = self.sizeY/self.rows
# How much padding the texture has
self.paddingX = textureSizeX - self.sizeX
self.paddingY = textureSizeY - self.sizeY
# Set UV padding
self.uPad = float(self.paddingX)/textureSizeX
self.vPad = float(self.paddingY)/textureSizeY
# The UV dimensions for each cell
self.uSize = (1.0 - self.uPad) / self.cols
self.vSize = (1.0 - self.vPad) / self.rows
self.cards = []
self.rowPerFace = rowPerFace
for i in range(len(rowPerFace)):
card = CardMaker("Sprite2d-Geom")
# The positions to create the card at
if anchorX == self.ALIGN_LEFT:
posLeft = 0
posRight = (self.colSize/scale)*repeatX
elif anchorX == self.ALIGN_CENTER:
posLeft = -(self.colSize/2.0/scale)*repeatX
posRight = (self.colSize/2.0/scale)*repeatX
elif anchorX == self.ALIGN_RIGHT:
posLeft = -(self.colSize/scale)*repeatX
posRight = 0
if anchorY == self.ALIGN_BOTTOM:
posTop = 0
posBottom = (self.rowSize/scale)*repeatY
elif anchorY == self.ALIGN_CENTER:
posTop = -(self.rowSize/2.0/scale)*repeatY
posBottom = (self.rowSize/2.0/scale)*repeatY
elif anchorY == self.ALIGN_TOP:
posTop = -(self.rowSize/scale)*repeatY
posBottom = 0
card.setFrame(posLeft, posRight, posTop, posBottom)
card.setHasUvs(True)
self.cards.append(self.node.attachNewNode(card.generate()))
self.cards[-1].setH(i * 360/len(rowPerFace))
# Since the texture is padded, we need to set up offsets and scales to make
# the texture fit the whole card
self.offsetX = (float(self.colSize)/textureSizeX)
self.offsetY = (float(self.rowSize)/textureSizeY)
# self.node.setTexScale(TextureStage.getDefault(), self.offsetX * repeatX, self.offsetY * repeatY)
# self.node.setTexOffset(TextureStage.getDefault(), 0, 1-self.offsetY)
self.texture = Texture()
self.texture.setXSize(textureSizeX)
self.texture.setYSize(textureSizeY)
self.texture.setZSize(1)
# Load the padded PNMImage to the texture
self.texture.load(self.paddedImg)
self.texture.setMagfilter(Texture.FTNearest)
self.texture.setMinfilter(Texture.FTNearest)
#Set up texture clamps according to repeats
if repeatX > 1:
self.texture.setWrapU(Texture.WMRepeat)
else:
self.texture.setWrapU(Texture.WMClamp)
if repeatY > 1:
self.texture.setWrapV(Texture.WMRepeat)
else:
self.texture.setWrapV(Texture.WMClamp)
self.node.setTexture(self.texture)
self.setFrame(0)
def nextsize(self, num):
""" Finds the next power of two size for the given integer. """
p2x=max(1,log(num,2))
notP2X=modf(p2x)[0]>0
return 2**int(notP2X+p2x)
def setFrame(self, frame=0):
""" Sets the current sprite to the given frame """
self.frameInterrupt = True # A flag to tell the animation task to shut it up ur face
self.currentFrame = frame
self.flipTexture()
def playAnim(self, animName, loop=False):
""" Sets the sprite to animate the given named animation. Booleon to loop animation"""
if not taskMgr.hasTaskNamed("Animate sprite" + self.spriteNum):
if hasattr(self, "task"):
taskMgr.remove("Animate sprite" + self.spriteNum)
del self.task
self.frameInterrupt = False # Clear any previous interrupt flags
self.loopAnim = loop
self.currentAnim = self.animations[animName]
self.currentAnim.playhead = 0
self.task = taskMgr.doMethodLater(1.0/self.currentAnim.fps,self.animPlayer, "Animate sprite" + self.spriteNum)
def createAnim(self, animName, frameCols, fps=12):
""" Create a named animation. Takes the animation name and a tuple of frame numbers """
self.animations[animName] = Sprite2d.Animation(frameCols, fps)
return self.animations[animName]
def flipX(self, val=None):
""" Flip the sprite on X. If no value given, it will invert the current flipping."""
if val:
self.flip['x'] = val
else:
if self.flip['x']:
self.flip['x'] = False
else:
self.flip['x'] = True
self.flipTexture()
return self.flip['x']
def flipY(self, val=None):
""" See flipX """
if val:
self.flip['y'] = val
else:
if self.flip['y']:
self.flip['y'] = False
else:
self.flip['y'] = True
self.flipTexture()
return self.flip['y']
def updateCameraAngle(self, cameraNode):
baseH = cameraNode.getH(render) - self.node.getH(render)
degreesBetweenCards = 360/len(self.cards)
bestCard = int(((baseH)+degreesBetweenCards/2)%360 / degreesBetweenCards)
#print baseH, bestCard
for i in range(len(self.cards)):
if i == bestCard:
self.cards[i].show()
else:
self.cards[i].hide()
def flipTexture(self):
""" Sets the texture coordinates of the texture to the current frame"""
for i in range(len(self.cards)):
currentRow = self.rowPerFace[i]
sU = self.offsetX * self.repeatX
sV = self.offsetY * self.repeatY
oU = 0 + self.currentFrame * self.uSize
#oU = 0 + self.frames[self.currentFrame].col * self.uSize
#oV = 1 - self.frames[self.currentFrame].row * self.vSize - self.offsetY
oV = 1 - currentRow * self.vSize - self.offsetY
if self.flip['x'] ^ i==1: ##hack to fix side view
#print "flipping, i = ",i
sU *= -1
#oU = self.uSize + self.frames[self.currentFrame].col * self.uSize
oU = self.uSize + self.currentFrame * self.uSize
if self.flip['y']:
sV *= -1
#oV = 1 - self.frames[self.currentFrame].row * self.vSize
oV = 1 - currentRow * self.vSize
self.cards[i].setTexScale(TextureStage.getDefault(), sU, sV)
self.cards[i].setTexOffset(TextureStage.getDefault(), oU, oV)
def clear(self):
""" Free up the texture memory being used """
self.texture.clear()
self.paddedImg.clear()
self.node.removeNode()
def animPlayer(self, task):
if self.frameInterrupt:
return task.done
#print "Playing",self.currentAnim.cells[self.currentAnim.playhead]
self.currentFrame = self.currentAnim.cells[self.currentAnim.playhead]
self.flipTexture()
if self.currentAnim.playhead+1 < len(self.currentAnim.cells):
self.currentAnim.playhead += 1
return task.again
if self.loopAnim:
self.currentAnim.playhead = 0
return task.again
class MazeMapGui(DirectFrame):
notify = directNotify.newCategory('MazeMapGui')
def __init__(self, mazeCollTable, maskResolution = None, radiusRatio = None, bgColor = (0.8, 0.8, 0.8), fgColor = (0.5, 0.5, 0.5, 1.0)):
DirectFrame.__init__(self, relief=None, state=DGG.NORMAL, sortOrder=DGG.BACKGROUND_SORT_INDEX)
self.hide()
self._bgColor = bgColor
self._fgColor = fgColor
self._mazeCollTable = mazeCollTable
self._mazeWidth = len(self._mazeCollTable[0])
self._mazeHeight = len(self._mazeCollTable)
self._maskResolution = maskResolution or DEFAULT_MASK_RESOLUTION
if radiusRatio is None:
self._radius = self._maskResolution * DEFAULT_RADIUS_RATIO
else:
self._radius = self._maskResolution * radiusRatio
self._revealedCells = []
for y in xrange(self._mazeHeight):
self._revealedCells.append([])
for u in xrange(self._mazeWidth):
self._revealedCells[y].append(False)
self._revealFunctions = {MazeRevealType.SmoothCircle: self._revealSmoothCircle,
MazeRevealType.HardCircle: self._revealHardCircle,
MazeRevealType.Square: self._revealSquare}
self._revealFunction = MAZE_REVEAL_TYPE
self.map = self._createMapTextureCard()
self.map.reparentTo(self)
self.maskedLayer = self.attachNewNode('maskedLayer')
self.mask = self._createMaskTextureCard()
self.mask.reparentTo(self)
self.visibleLayer = self.attachNewNode('visibleLayer')
self._laffMeterModel = loader.loadModel('phase_3/models/gui/laff_o_meter')
self._toon2marker = {}
return
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 _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 _drawSquare(self, image, ulx, uly, size, color):
x = int(ulx)
while x <= ulx + size:
y = int(uly)
while y <= uly + size:
if x > 0 and y > 0 and x < image.getXSize() and y < image.getYSize():
image.setXelA(x, y, color)
y += 1
x += 1
def destroy(self):
del self._mazeCollTable
del self._maskResolution
del self._radius
del self._revealedCells
del self._revealFunctions
del self._revealFunction
self.map.removeNode()
del self.map
self.mask.removeNode()
del self.mask
self.maskedLayer.removeNode()
del self.maskedLayer
self.visibleLayer.removeNode()
del self.visibleLayer
self._maskImage.clear()
del self._maskImage
self.maskTexture.clear()
del self.maskTexture
self._laffMeterModel.removeNode()
del self._laffMeterModel
DirectFrame.destroy(self)
def _revealSmoothCircle(self, x, y, center):
length = (Vec2(x, y) - center).length()
goalAlpha = max(0.0, length / float(self._radius) - 0.5)
self._maskImage.setXelA(x, y, VBase4D(0.0, 0.0, 0.0, min(self._maskImage.getAlpha(x, y), goalAlpha * 2.0)))
def _revealHardCircle(self, x, y, center):
length = (Vec2(x, y) - center).length()
if length <= self._radius:
self._maskImage.setXelA(x, y, VBase4D(0, 0, 0, 0))
def _revealSquare(self, x, y, center):
self._maskImage.setXelA(x, y, VBase4D(0, 0, 0, 0))
def _drawHole(self, x, y):
center = Vec2(x, y)
ul = center - Vec2(self._radius, self._radius)
lr = center + Vec2(self._radius, self._radius)
x = int(ul[0])
while x <= lr[0]:
y = int(ul[1])
while y <= lr[1]:
if x > 0 and y > 0 and x < self._maskResolution and y < self._maskResolution:
self._revealFunctions[self._revealFunction](x, y, center)
y += 1
x += 1
self.maskTexture.load(self._maskImage)
self.mask.setTexture(self.maskTexture, 1)
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 tile2gui(self, x, y):
y = self._mazeHeight - y
cellWidth = self._maskResolution / self._mazeWidth
cellHeight = self._maskResolution / self._mazeHeight
ax = float(x) / self._mazeWidth * self._maskResolution
ax += cellWidth
ay = float(y) / self._mazeHeight * self._maskResolution
ay += cellHeight
return (ax, ay)
def gui2pos(self, x, y):
return (x / self._maskResolution * 2.0 - 0.97, 0, y / self._maskResolution * -2.0 + 1.02)
def _getToonMarker(self, toon):
hType = toon.style.getType()
if hType == 'rabbit':
hType = 'bunny'
return self._laffMeterModel.find('**/' + hType + 'head')
def addToon(self, toon, tX, tY):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(0.07)
else:
marker.setScale(0.05)
marker.flattenStrong()
marker.setPos(*self.gui2pos(*self.tile2gui(tX, tY)))
self._toon2marker[toon] = marker
def removeToon(self, toon):
if not self._toon2marker.has_key(toon):
return
self._toon2marker[toon].removeNode()
del self._toon2marker[toon]
def updateToon(self, toon, tX, tY):
if not self._toon2marker.has_key(toon):
return
x, y = self.tile2gui(tX, tY)
self._toon2marker[toon].setPos(*self.gui2pos(x, y))
if tY < 0 or tY >= len(self._revealedCells):
self.notify.warning('updateToon earlying out:')
self.notify.warning('(tX, tY): (%s, %s)' % (tX, tY))
self.notify.warning('len(_revealedCells): %s' % (len(self._revealedCells),))
if len(self._revealedCells) > 0:
self.notify.warning('len(_revealedCells[0]): %s' % (len(self._revealedCells[0]),))
return
if tX < 0 or tX >= len(self._revealedCells[tY]):
self.notify.warning('updateToon earlying out:')
self.notify.warning('(tX, tY): (%s, %s)' % (tX, tY))
self.notify.warning('len(_revealedCells): %s' % (len(self._revealedCells),))
if tY < len(self._revealedCells):
self.notify.warning('len(_revealedCells[tY]): %s' % (len(self._revealedCells[tY]),))
elif len(self._revealedCells) > 0:
self.notify.warning('len(_revealedCells[0]): %s' % (len(self._revealedCells[0]),))
return
if not self._revealedCells[tY][tX]:
self._drawHole(x, y)
self._revealedCells[tY][tX] = True
def revealCell(self, x, y):
ax, ay = self.tile2gui(x, y)
if not self._revealedCells[y][x]:
self._drawHole(ax, ay)
self._revealedCells[y][x] = True
def revealAll(self):
for x in xrange(self._maskResolution):
for y in xrange(self._maskResolution):
self._maskImage.setXelA(x, y, 0, 0, 0, 0)
self.revealCell(0, 0)
def reset(self):
for x in xrange(self._maskResolution):
for y in xrange(self._maskResolution):
self._maskImage.setXelA(x, y, 0, 0, 0, 1)
class Effect:
baseWidth = 0
baseHeight = 0
effectWidth = 1
effectHeight = 1
effectTargetMS = 143
noSampling = False
tex = None
loadedFormat = None
# Animation variables
internalFrameIndex = 1
startIndex = 1
endIndex = 1
loopEffect = False
# XML variables
tree = None
frames = None
colors = None
tweens = None
compositeFrames = None
# Nodes
consumedNodesList = None
# Accessible object (nodePath)
effectCameraNodePath = None
effectCardNodePath = None
# Constant value; Unit comparison for card size; basis is from cure, which is [140x110]
cardDimensionBasis = [-5.0, 5.0, 0.0, 10.0, 140.0, 110.0]
pixelScaleX = cardDimensionBasis[4]/(cardDimensionBasis[1]-cardDimensionBasis[0])
pixelScaleZ = cardDimensionBasis[5]/(cardDimensionBasis[3]-cardDimensionBasis[2])
effectIsCentered = True
effectAdjustment = [0, 0, 0]
def __init__(self, effectFileName, parent=None, loop=False, effectIsCentered=True, effectAdjustment=[0, 0, 0]):
self.effectAdjustment = effectAdjustment
self.loopEffect = loop
self.effectIsCentered = effectIsCentered
self.loadedFormat = None
if effectFileName != None:
effectFileNameSplit = effectFileName.split('.')
self.loadedFormat = effectFileNameSplit[len(effectFileNameSplit)-2] # Get value at penultimate index
if self.loadedFormat == effectFileNameSplit[0]:
self.loadedFormat = None # Get rid of bad format name.
pass
# Load texture; supply alpha channel if it doesn't exist.
p = transparencyKey(effectFileName)
self.tex = Texture()
self.tex.setup2dTexture(p.getXSize(), p.getYSize(), Texture.TUnsignedByte, Texture.FRgba)
self.tex.load(p)
if self.loadedFormat != None:
try:
self.tree = etree.parse("./"+GAME+"/effects/"+self.loadedFormat+"/sprite.xml")
except IOError:
self.loadedFormat = None
pass
if self.loadedFormat != None:
root = self.tree.getroot()
self.frames = root.find('.//frames')
self.colors = root.find('.//colors')
self.tweens = root.find('.//motion-tweens')
self.compositeFrames = root.find('.//composite-frames')
self.baseWidth = 0 if root.attrib.get("base-width") == None else float(root.attrib.get("base-width"))
self.baseHeight = 0 if root.attrib.get("base-height") == None else float(root.attrib.get("base-height"))
self.effectWidth = 1 if root.attrib.get("frame-width") == None else float(root.attrib.get("frame-width"))
self.effectHeight = 1 if root.attrib.get("frame-height") == None else float(root.attrib.get("frame-height"))
self.effectTargetMS = 143 if root.attrib.get("target-ms") == None else float(root.attrib.get("target-ms"))
self.startIndex = 1 if root.attrib.get("target-start") == None else int(root.attrib.get("target-start"))
self.endIndex = 1 if root.attrib.get("target-end") == None else int(root.attrib.get("target-end"))
self.noSampling = False if root.attrib.get("no-sampling") == None else bool(root.attrib.get("no-sampling"))
if self.noSampling==True:
self.tex.setMagfilter(Texture.FTNearest)
self.tex.setMinfilter(Texture.FTNearest)
cm = CardMaker('card-'+effectFileName)
cardDeltaX = self.effectWidth / self.pixelScaleX
cardDeltaZ = self.effectHeight / self.pixelScaleZ
if self.effectIsCentered == True:
cm.setFrame(0, 0, 0, 0)
deltaX = (cardDeltaX/2.0) - (-cardDeltaX/2.0)
deltaY = 0
deltaZ = (cardDeltaZ/2.0) - (-cardDeltaZ/2.0)
#occluder = OccluderNode('effect-parent-occluder', Point3((-cardDeltaX/2.0), 0, (-cardDeltaZ/2.0)), Point3((-cardDeltaX/2.0), 0, (cardDeltaZ/2.0)), Point3((cardDeltaX/2.0), 0, (cardDeltaZ/2.0)), Point3((cardDeltaX/2.0), 0, (-cardDeltaZ/2.0)))
else:
cm.setFrame(0, 0, 0, 0)
deltaX = (cardDeltaX/2.0) - (-cardDeltaX/2.0)
deltaY = 0
deltaZ = cardDeltaZ - 0
#occluder = OccluderNode('effect-parent-occluder', Point3((-cardDeltaX/2.0), 0, 0), Point3((-cardDeltaX/2.0), 0, cardDeltaZ), Point3((cardDeltaX/2.0), 0, cardDeltaZ), Point3((cardDeltaX/2.0), 0, 0))
self.effectCardNodePath = render.attachNewNode(cm.generate())
self.effectCardNodePath.setBillboardPointEye()
self.effectCardNodePath.reparentTo(parent)
#occluder_nodepath = self.effectCardNodePath.attachNewNode(occluder)
#self.effectCardNodePath.setOccluder(occluder_nodepath)
emptyNode = NodePath('effect-parent-translator')
emptyNode.reparentTo(self.effectCardNodePath)
if effectIsCentered == True:
emptyNode.setPos(-deltaX/2.0+self.effectAdjustment[0], 0+self.effectAdjustment[1], deltaZ/2.0+self.effectAdjustment[2])
else:
emptyNode.setPos(-deltaX/2.0+self.effectAdjustment[0], 0+self.effectAdjustment[1], deltaZ+self.effectAdjustment[2])
#emptyNode.place()
emptyNode.setSx(float(deltaX)/self.effectWidth)
emptyNode.setSz(float(deltaZ)/self.effectHeight)
self.effectCameraNodePath = emptyNode
if parent != None:
self.effectCardNodePath.reparentTo(parent)
else:
self.effectCardNodePath.reparentTo(render)
#self.effectCardNodePath.place()
self.effectCardNodePath.setBin("fixed", 40)
self.effectCardNodePath.setDepthTest(False)
self.effectCardNodePath.setDepthWrite(False)
pass
def getSequence(self):
sequence = Sequence()
for x in range(self.startIndex, self.endIndex, 1):
sequence.append(Func(self.pandaRender))
sequence.append(Func(self.advanceFrame))
sequence.append(Wait(self.effectTargetMS * 0.001))
sequence.append(Func(self.clearNodesForDrawing))
sequence.append(Func(self.advanceFrame))
sequence.append(Wait(self.effectTargetMS * 0.001))
return sequence
pass
def hasEffectFinished(self):
if self.internalFrameIndex > self.endIndex and self.loopEffect == False:
return True
else:
return False
pass
def advanceFrame(self):
if self.internalFrameIndex < self.endIndex:
self.internalFrameIndex += 1
elif self.internalFrameIndex == self.endIndex and self.loopEffect == True:
self.internalFrameIndex = self.startIndex
else:
self.internalFrameIndex = self.endIndex + 1
self.clearNodesForDrawing()
pass
def clearNodesForDrawing(self):
if False:
self.effectCameraNodePath.analyze()
if self.consumedNodesList != None and self.consumedNodesList != []:
for consumedNode in self.consumedNodesList:
consumedNode.removeNode()
self.consumedNodesList = []
pass
def pandaRender(self):
frameList = []
for node in self.compositeFrames.getiterator('composite-frame'):
if node.tag == "composite-frame" and node.attrib.get("id") == str(self.internalFrameIndex):
for frameCallNode in node:
for frameNode in self.frames.getiterator('frame'):
if frameNode.tag == "frame" and frameNode.attrib.get("id") == frameCallNode.attrib.get("id"):
offsetX = 0 if frameCallNode.attrib.get("offset-x") == None else float(frameCallNode.attrib.get("offset-x"))
offsetY = 0 if frameCallNode.attrib.get("offset-y") == None else float(frameCallNode.attrib.get("offset-y"))
tweenId = frameCallNode.attrib.get("tween")
frameInTween = 0 if frameCallNode.attrib.get("frame-in-tween") == None else int(frameCallNode.attrib.get("frame-in-tween"))
addWidth = 0 if frameNode.attrib.get("w") == None else float(frameNode.attrib.get("w"))
addHeight = 0 if frameNode.attrib.get("h") == None else float(frameNode.attrib.get("h"))
sInPixels = 0 if frameNode.attrib.get("s") == None else float(frameNode.attrib.get("s"))
tInPixels = 0 if frameNode.attrib.get("t") == None else float(frameNode.attrib.get("t"))
swInPixels = sInPixels + addWidth
thInPixels = tInPixels + addHeight
s = (sInPixels / self.baseWidth)
t = 1 - (tInPixels / self.baseHeight) # Complemented to deal with loading image upside down.
S = (swInPixels / self.baseWidth)
T = 1 - (thInPixels / self.baseHeight) # Complemented to deal with loading image upside down.
blend = "overwrite" if frameCallNode.attrib.get("blend") == None else frameCallNode.attrib.get("blend")
scaleX = 1 if frameCallNode.attrib.get("scale-x") == None else float(frameCallNode.attrib.get("scale-x"))
scaleY = 1 if frameCallNode.attrib.get("scale-y") == None else float(frameCallNode.attrib.get("scale-y"))
color = Color(1,1,1,1)
tweenHasColor = False
frameCallHasColor = False
frameCallColorName = frameCallNode.attrib.get("color-name")
if frameCallColorName != None:
# Get color at frame call as first resort.
frameCallHasColor = True
for colorNode in self.colors.getiterator('color'):
if colorNode.tag == 'color' and colorNode.attrib.get("name") == frameCallColorName:
R = 1 if colorNode.attrib.get("r") == None else float(colorNode.attrib.get("r"))
G = 1 if colorNode.attrib.get("g") == None else float(colorNode.attrib.get("g"))
B = 1 if colorNode.attrib.get("b") == None else float(colorNode.attrib.get("b"))
A = 1 if colorNode.attrib.get("a") == None else float(colorNode.attrib.get("a"))
color = Color(R, G, B, A)
break # leave for loop when we find the correct color
pass
if tweenId != None and tweenId != "0":
# Get color at tween frame as second resort.
thisTween = None
frameLength = 1
advancementFunction = "linear"
foundTween = False
pointList = []
colorList = []
for tweenNode in self.tweens.getiterator('motion-tween'):
if tweenNode.tag == "motion-tween" and tweenNode.attrib.get("id") == tweenId:
foundTween = True
frameLength = 1 if tweenNode.attrib.get("length-in-frames") == None else tweenNode.attrib.get("length-in-frames")
advancementFunction = "linear" if tweenNode.attrib.get("advancement-function") == None else tweenNode.attrib.get("advancement-function")
for pointOrColorNode in tweenNode.getiterator():
if pointOrColorNode.tag == "point":
pX = 0 if pointOrColorNode.attrib.get("x") == None else float(pointOrColorNode.attrib.get("x"))
pY = 0 if pointOrColorNode.attrib.get("y") == None else float(pointOrColorNode.attrib.get("y"))
pointList.append(Point(pX, pY, 0))
elif pointOrColorNode.tag == "color-state":
colorName = "white" if pointOrColorNode.attrib.get("name") == None else pointOrColorNode.attrib.get("name")
for colorNode in self.colors.getiterator('color'):
if colorNode.tag == 'color' and colorNode.attrib.get("name") == colorName:
R = 1 if colorNode.attrib.get("r") == None else float(colorNode.attrib.get("r"))
G = 1 if colorNode.attrib.get("g") == None else float(colorNode.attrib.get("g"))
B = 1 if colorNode.attrib.get("b") == None else float(colorNode.attrib.get("b"))
A = 1 if colorNode.attrib.get("a") == None else float(colorNode.attrib.get("a"))
colorList.append(Color(R, G, B, A))
break # leave for loop when we find the correct color reference
pass # Run through all child nodes of selected tween
break # Exit after finding correct tween
pass
if foundTween:
thisTween = Tween(frameLength, advancementFunction, pointList, colorList)
offset = thisTween.XYFromFrame(frameInTween);
offsetFromTweenX = int(offset.X);
offsetFromTweenY = int(offset.Y);
offsetX += int(offset.X);
offsetY += int(offset.Y);
if thisTween.hasColorComponent():
tweenHasColor = True;
if frameCallHasColor == False:
color = thisTween.colorFromFrame(frameInTween);
pass
if frameNode.attrib.get("color-name") != None and frameCallHasColor == False and tweenHasColor == False:
# Get color at frame definition as last resort.
for colorNode in colors.getiterator('color'):
if colorNode.tag == 'color' and colorNode.attrib.get("name") == frameNode.attrib.get("color-name"):
R = 1 if colorNode.attrib.get("r") == None else float(colorNode.attrib.get("r"))
G = 1 if colorNode.attrib.get("g") == None else float(colorNode.attrib.get("g"))
B = 1 if colorNode.attrib.get("b") == None else float(colorNode.attrib.get("b"))
A = 1 if colorNode.attrib.get("a") == None else float(colorNode.attrib.get("a"))
color = Color(R, G, B, A)
break # leave for loop when we find the correct color
pass
rotationZ = 0 if frameCallNode.attrib.get("rotation-z") == None else float(frameCallNode.attrib.get("rotation-z"))
frameList.append(Frame(Bound(offsetX, offsetY, addWidth, addHeight), s, t, S, T, blend, scaleX, scaleY, color, rotationZ))
pass
break # Leave once we've found the appropriate frame
# Prepare tracking list of consumed nodes.
self.clearNodesForDrawing()
# Make an identifier to tack onto primitive names in Panda3d's scene graph.
frameIndexForName = 1
# Loop through loaded frames that make up composite frame.
for loadedFrame in frameList:
# For debugging purposes, print the object.
if False:
loadedFrame.printAsString()
# Set up place to store primitive 3d object; note: requires vertex data made by GeomVertexData
squareMadeByTriangleStrips = GeomTristrips(Geom.UHDynamic)
# Set up place to hold 3d data and for the following coordinates:
# square's points (V3: x, y, z),
# the colors at each point of the square (c4: r, g, b, a), and
# for the UV texture coordinates at each point of the square (t2: S, T).
vertexData = GeomVertexData('square-'+str(frameIndexForName), GeomVertexFormat.getV3c4t2(), Geom.UHDynamic)
vertex = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
texcoord = GeomVertexWriter(vertexData, 'texcoord')
# Add the square's data
# Upper-Left corner of square
vertex.addData3f(-loadedFrame.bound.Width / 2.0, 0, -loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R,loadedFrame.color.G,loadedFrame.color.B,loadedFrame.color.A)
texcoord.addData2f(loadedFrame.s, loadedFrame.T)
# Upper-Right corner of square
vertex.addData3f(loadedFrame.bound.Width / 2.0, 0, -loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R,loadedFrame.color.G,loadedFrame.color.B,loadedFrame.color.A)
texcoord.addData2f(loadedFrame.S, loadedFrame.T)
# Lower-Left corner of square
vertex.addData3f(-loadedFrame.bound.Width / 2.0, 0, loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R,loadedFrame.color.G,loadedFrame.color.B,loadedFrame.color.A)
texcoord.addData2f(loadedFrame.s, loadedFrame.t)
# Lower-Right corner of square
vertex.addData3f(loadedFrame.bound.Width / 2.0, 0, loadedFrame.bound.Height / 2.0)
color.addData4f(loadedFrame.color.R,loadedFrame.color.G,loadedFrame.color.B,loadedFrame.color.A)
texcoord.addData2f(loadedFrame.S, loadedFrame.t)
# Pass data to primitive
squareMadeByTriangleStrips.addNextVertices(4)
squareMadeByTriangleStrips.closePrimitive()
square = Geom(vertexData)
square.addPrimitive(squareMadeByTriangleStrips)
# Pass primtive to drawing node
drawPrimitiveNode=GeomNode('square-'+str(frameIndexForName))
drawPrimitiveNode.addGeom(square)
# Pass node to scene (effect camera)
nodePath = self.effectCameraNodePath.attachNewNode(drawPrimitiveNode)
# Linear dodge:
if loadedFrame.blendMode == "darken":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOneMinusFbufferColor, ColorBlendAttrib.OOneMinusIncomingColor))
pass
elif loadedFrame.blendMode == "multiply":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OFbufferColor, ColorBlendAttrib.OZero))
pass
elif loadedFrame.blendMode == "color-burn":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OZero, ColorBlendAttrib.OOneMinusIncomingColor))
pass
elif loadedFrame.blendMode == "linear-burn":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OZero, ColorBlendAttrib.OIncomingColor))
pass
elif loadedFrame.blendMode == "lighten":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MMax, ColorBlendAttrib.OIncomingColor, ColorBlendAttrib.OFbufferColor))
pass
elif loadedFrame.blendMode == "color-dodge":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOne))
pass
elif loadedFrame.blendMode == "linear-dodge":
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOneMinusIncomingColor))
pass
else: # Overwrite:
nodePath.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OIncomingAlpha, ColorBlendAttrib.OOneMinusIncomingAlpha))
pass
nodePath.setDepthTest(False)
# Apply texture
nodePath.setTexture(self.tex)
# Apply translation, then rotation, then scaling to node.
nodePath.setPos((loadedFrame.bound.X + loadedFrame.bound.Width / 2.0, 1, -loadedFrame.bound.Y - loadedFrame.bound.Height / 2.0))
nodePath.setR(loadedFrame.rotationZ)
nodePath.setScale(loadedFrame.scaleX, 1, loadedFrame.scaleY)
nodePath.setTwoSided(True)
self.consumedNodesList.append(nodePath)
frameIndexForName = frameIndexForName + 1
# Loop continues on through each frame called in the composite frame.
pass
class HtmlView(DirectObject):
notify = DirectNotifyGlobal.directNotify.newCategory('HtmlView')
useHalfTexture = base.config.GetBool('news-half-texture', 0)
def __init__(self, parent=aspect2d):
global GlobalWebcore
self.parent = parent
self.mx = 0
self.my = 0
self.htmlFile = 'index.html'
self.transparency = False
if GlobalWebcore:
pass
else:
GlobalWebcore = AwWebCore(AwWebCore.LOGVERBOSE, True,
AwWebCore.PFBGRA)
GlobalWebcore.setBaseDirectory('.')
for errResponse in xrange(400, 600):
GlobalWebcore.setCustomResponsePage(errResponse, 'error.html')
self.webView = GlobalWebcore.createWebView(WEB_WIDTH, WEB_HEIGHT,
self.transparency, False,
70)
frameName = ''
inGameNewsUrl = self.getInGameNewsUrl()
self.imgBuffer = array.array('B')
for i in xrange(WEB_WIDTH * WEB_HEIGHT):
self.imgBuffer.append(0)
self.imgBuffer.append(0)
self.imgBuffer.append(0)
self.imgBuffer.append(255)
if self.useHalfTexture:
self.leftBuffer = array.array('B')
for i in xrange(WEB_HALF_WIDTH * WEB_HEIGHT):
self.leftBuffer.append(0)
self.leftBuffer.append(0)
self.leftBuffer.append(0)
self.leftBuffer.append(255)
self.rightBuffer = array.array('B')
for i in xrange(WEB_HALF_WIDTH * WEB_HEIGHT):
self.rightBuffer.append(0)
self.rightBuffer.append(0)
self.rightBuffer.append(0)
self.rightBuffer.append(255)
self.setupTexture()
if self.useHalfTexture:
self.setupHalfTextures()
self.accept('mouse1', self.mouseDown, [AwWebView.LEFTMOUSEBTN])
self.accept('mouse3', self.mouseDown, [AwWebView.RIGHTMOUSEBTN])
self.accept('mouse1-up', self.mouseUp, [AwWebView.LEFTMOUSEBTN])
self.accept('mouse3-up', self.mouseUp, [AwWebView.RIGHTMOUSEBTN])
def getInGameNewsUrl(self):
result = base.config.GetString(
'fallback-news-url',
'http://cdn.toontown.disney.go.com/toontown/en/gamenews/')
override = base.config.GetString('in-game-news-url', '')
if override:
self.notify.info(
'got an override url, using %s for in a game news' % override)
result = override
else:
try:
launcherUrl = base.launcher.getValue('GAME_IN_GAME_NEWS_URL',
'')
if launcherUrl:
result = launcherUrl
self.notify.info(
'got GAME_IN_GAME_NEWS_URL from launcher using %s' %
result)
else:
self.notify.info(
'blank GAME_IN_GAME_NEWS_URL from launcher, using %s' %
result)
except:
self.notify.warning(
'got exception getting GAME_IN_GAME_NEWS_URL from launcher, using %s'
% result)
return result
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 setupHalfTextures(self):
self.setupLeftTexture()
self.setupRightTexture()
self.fullPnmImage = PNMImage(WEB_WIDTH, WEB_HEIGHT, 4)
self.leftPnmImage = PNMImage(WEB_HALF_WIDTH, WEB_HEIGHT, 4)
self.rightPnmImage = PNMImage(WEB_HALF_WIDTH, WEB_HEIGHT, 4)
def setupLeftTexture(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)
cm.setFrame(-htmlWidth / 2.0, 0, -htmlHeight / 2.0, htmlHeight / 2.0)
card = cm.generate()
self.leftQuad = NodePath(card)
self.leftQuad.reparentTo(self.parent)
self.leftGuiTex = Texture('guiTex')
self.leftGuiTex.setupTexture(Texture.TT2dTexture, WEB_HALF_WIDTH,
WEB_HEIGHT, 1, Texture.TUnsignedByte,
Texture.FRgba)
self.leftGuiTex.setKeepRamImage(True)
self.leftGuiTex.makeRamImage()
self.leftGuiTex.setWrapU(Texture.WMClamp)
self.leftGuiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('leftWebTS')
self.leftQuad.setTexture(ts, self.leftGuiTex)
self.leftQuad.setTexScale(ts, 1.0, -1.0)
self.leftQuad.setTransparency(0)
self.leftQuad.setTwoSided(True)
self.leftQuad.setColor(1.0, 1.0, 1.0, 1.0)
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)
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 calcMouseLimits(self):
ll = Point3()
ur = Point3()
self.quad.calcTightBounds(ll, ur)
self.notify.debug('ll=%s ur=%s' % (ll, ur))
offset = self.quad.getPos(aspect2d)
self.notify.debug('offset = %s ' % offset)
ll.setZ(ll.getZ() + offset.getZ())
ur.setZ(ur.getZ() + offset.getZ())
self.notify.debug('new LL=%s, UR=%s' % (ll, ur))
relPointll = self.quad.getRelativePoint(aspect2d, ll)
self.notify.debug('relPoint = %s' % relPointll)
self.mouseLL = (aspect2d.getScale()[0] * ll[0],
aspect2d.getScale()[2] * ll[2])
self.mouseUR = (aspect2d.getScale()[0] * ur[0],
aspect2d.getScale()[2] * ur[2])
self.notify.debug('original mouseLL=%s, mouseUR=%s' %
(self.mouseLL, self.mouseUR))
def writeTex(self, filename='guiText.png'):
self.notify.debug('writing texture')
self.guiTex.generateRamMipmapImages()
self.guiTex.write(filename)
def toggleRotation(self):
if self.interval.isPlaying():
self.interval.finish()
else:
self.interval.loop()
def mouseDown(self, button):
messenger.send('wakeup')
self.webView.injectMouseDown(button)
def mouseUp(self, button):
self.webView.injectMouseUp(button)
def reload(self):
pass
def zoomIn(self):
self.webView.zoomIn()
def zoomOut(self):
self.webView.zoomOut()
def toggleTransparency(self):
self.transparency = not self.transparency
self.webView.setTransparent(self.transparency)
def update(self, task):
if base.mouseWatcherNode.hasMouse():
x, y = self._translateRelativeCoordinates(
base.mouseWatcherNode.getMouseX(),
base.mouseWatcherNode.getMouseY())
if self.mx - x != 0 or self.my - y != 0:
self.webView.injectMouseMove(x, y)
self.mx, self.my = x, y
if self.webView.isDirty():
self.webView.render(self.imgBuffer.buffer_info()[0],
WEB_WIDTH * 4, 4)
Texture.setTexturesPower2(2)
textureBuffer = self.guiTex.modifyRamImage()
textureBuffer.setData(self.imgBuffer.tostring())
if self.useHalfTexture:
self.guiTex.store(self.fullPnmImage)
self.leftPnmImage.copySubImage(self.fullPnmImage, 0, 0, 0,
0, WEB_HALF_WIDTH,
WEB_HEIGHT)
self.rightPnmImage.copySubImage(self.fullPnmImage, 0, 0,
WEB_HALF_WIDTH, 0,
WEB_HALF_WIDTH, WEB_HEIGHT)
self.leftGuiTex.load(self.leftPnmImage)
self.rightGuiTex.load(self.rightPnmImage)
self.quad.hide()
Texture.setTexturesPower2(1)
GlobalWebcore.update()
return Task.cont
def _translateRelativeCoordinates(self, x, y):
sx = int((x - self.mouseLL[0]) / (self.mouseUR[0] - self.mouseLL[0]) *
WEB_WIDTH_PIXELS)
sy = WEB_HEIGHT_PIXELS - int(
(y - self.mouseLL[1]) /
(self.mouseUR[1] - self.mouseLL[1]) * WEB_HEIGHT_PIXELS)
return (sx, sy)
def unload(self):
self.ignoreAll()
self.webView.destroy()
self.webView = None
return
def onCallback(self, name, args):
if name == 'requestFPS':
pass
def onBeginNavigation(self, url, frameName):
pass
def onBeginLoading(self, url, frameName, statusCode, mimeType):
pass
def onFinishLoading(self):
self.notify.debug('finished loading')
def onReceiveTitle(self, title, frameName):
pass
def onChangeTooltip(self, tooltip):
pass
def onChangeCursor(self, cursor):
pass
def onChangeKeyboardFocus(self, isFocused):
pass
def onChangeTargetURL(self, url):
pass
class World:
def __init__(self, actor, state, lvl):
#Setzte die Parameter
self.CActor = actor #Spieler erstellen
self.CGame = state #FSM - Gamestate erstellen
self.mission = lvl #Aktuelle Mission
self.mMission = None
#Grundeinstellen fuer die Welt
base.disableMouse() #Mouse ausmachen
self.slowdown = 1 #Schnelligkeitsfaktor 1=Normal
self.hud = False
file, filename, description = imp.find_module("mission" +
str(self.mission))
self.mMission = imp.load_module("mission" + str(self.mission), file,
filename, description)
#SPIELER - Variablen
self.oldactorlevel = self.CActor.getLevel()
self.CActor.CActorShip.setX(
-165) #Setze den Spieler links im Bildschirm
self.CActor.CActorShip.setY(0)
self.CActor.nActorShip.reparentTo(render)
self.CActor.CActorShip.getWeapon().setWeapon(
"laserGun") #Standardwaffe setzen
self.maxshield = self.CActor.CActorShip.getShield(
) #Schild speichern um Prozent berechnen zu koennen
self.hitted = False #Variable um abzufragen ob man getroffen wurde
self.dead = False #Spieler lebt
self.lbullets = [] #Spielerbullets
self.lbulletsspeed = []
self.lcanon = [] #Spielercanonbullets
self.lcanonspeed = []
self.cameraeffectx = 0 #X-Wert der Camera um eine Sinuskurve zu implementieren
self.cameraeffectamplitude = 5 #Die Amplitude der Sinuswelle - Maxima
self.exppercent = (self.CActor.getExperience() * 100
) / self.CActor.getMaxExperience() #EXP in Prozent
self.oldcash = self.CActor.getMoney()
self.secweapon = 3
#Resultattexte, wenn die Mission zu ende ist
self.txtresultmission = addText(-0.15, 0.35, "")
self.txtresultkills = addText(-0.15, 0.25, "")
self.txtresultleft = addText(-0.15, 0.20, "")
self.txtresultcash = addText(-0.15, 0.15, "")
self.txtresultlevel = addText(-0.15, 0.10, "")
self.txtresultmessage = addText(-0.15, 0.0, "")
#ALLES FUER MOTION BLUR ***********************************************************************
#Eine Texture erstellen, welches in das Hauptfenster kopiert wird
self.CTex = Texture()
self.CTex.setMinfilter(Texture.FTLinear)
base.win.addRenderTexture(self.CTex,
GraphicsOutput.RTMTriggeredCopyTexture)
#Eine andere 2D Kamera erstellen, welches vor der Hauptkamera gerendert wird
self.backcam = base.makeCamera2d(base.win, sort=-10)
self.background = NodePath("background")
self.backcam.reparentTo(self.background)
self.background.setDepthTest(0)
self.background.setDepthWrite(0)
self.backcam.node().getDisplayRegion(0).setClearDepthActive(0)
#Zwei Texturekarten ersten. Eins bevor, eins danach
self.bcard = base.win.getTextureCard()
self.bcard.reparentTo(self.background)
self.bcard.setTransparency(1)
self.fcard = base.win.getTextureCard()
self.fcard.reparentTo(render2d)
self.fcard.setTransparency(1)
#**********************************************************************************************
#Drops als Liste
self.ldrop = []
#Explosionen - oder besser gesagt Splittereffekt als Liste
self.lexplosions = []
#Soundklasse erstellen um Zugriff auf die Sound zu haben
self.CSound = SoundMng()
self.CSound.sndFlyAmbience.play()
#GEGNER - Variablen
self.destroyedenemy = 0
self.lostenemy = 0
self.lenemys = [] #Gegnerspeicher
self.lbulletsenemy = [] #Gegnerbullets
self.newwave = False #Boolean,welches eine neue Gegnerwelle angibt
#Effekte
self.CEffects = Effects() #Effektklasse erstellen
#self.CEffects.createSpaceStars("particle/background.ptf") #Hintergrundeffekt erstellen
#Die Game-Loop Voreinstellungen
self.gameTask = taskMgr.add(self.gameLoop, "gameLoop")
self.gameTask.last = 0
self.gameTask.nextbullet = 0 #Timer wann geschossen werden darf, vom Spieler
self.gameTask.gotHit = 0
self.gameTask.lnextenemybullet = [
] #Timer wann geschossen werden darf, unabhaengig von welche Gegner
self.gameTask.resultkills = 0 #Timer fuer die Kills, im Resultat
self.gameTask.resultleft = 0 #Timer fuer die geflohenen Gegner, im Resultat
self.gameTask.introduction = 0
self.gameTask.introdelete = 0
self.gameTask.won = 0
self.resultcounter = 0 #Zeahler der die Nummern der Kills im Result aktualisiert
self.resultcounterleft = 0 #Zeahler der die Nummern der geflohenen Gegner im Result aktualisiert
self.introcounter = 0
self.ldata = []
self.readytospawn = False
self.musicplayed = False
self.musicplayed2 = False
self.resultplayed = False
#2D Kamera erstellen
lens = OrthographicLens()
lens.setFilmSize(350, 250)
base.cam.node().setLens(lens)
def gameLoop(self, task):
#Clock fuer FPS unabhaengige Bewegung
elapsed = globalClock.getDt()
if task.time > task.introduction:
if (self.mMission.getIntroduction(self.introcounter) == True):
self.introcounter += 1
task.introduction = task.time + 0.1
else:
task.introdelete = task.introduction + 3
if task.time > task.introdelete:
if self.musicplayed == False:
self.CSound.sndMusic.play()
self.musicplayed = True
self.toogleHud()
self.mMission.removeIntroduction()
if self.mMission.getSituation(task.time) == True:
for i in range(3):
self.ldata.append(self.mMission.getEnemies(i))
self.createEnemys(self.ldata[len(self.ldata) - 3],
self.ldata[len(self.ldata) - 1])
self.spawnEnemys(200, self.ldata[len(self.ldata) - 2])
#Die Position der Gegner aktualisieren
for obj in self.lenemys:
self.updatePosEnemy(obj, elapsed)
if obj.nEnemyShip.isEmpty() == 0:
if obj.CEnemyShip.getX() < -180:
obj.nEnemyShip.removeNode()
self.lostenemy += 1
if obj.CEnemyShip.getX() > 170:
obj.nEnemyShip.detachNode()
if obj.CEnemyShip.getX() < 170 and obj.CEnemyShip.getX(
) > -150:
obj.nEnemyShip.reparentTo(render)
if self.destroyedenemy + self.lostenemy == self.mMission.MAX_ENEMYS:
if task.won == 0:
task.won = task.time + 3
if task.won < task.time and self.musicplayed2 == False:
self.CSound.sndMusic.stop()
self.musicplayed2 = True
task.won = task.time + 3
if task.won < task.time:
if self.resultplayed == False:
self.CSound.sndResult.play()
self.CSound.sndFlyAmbience.stop()
self.resultplayed = True
for drop in self.ldrop:
drop.remove()
self.txthp.destroy()
self.txtshield.destroy()
self.txtlvl.destroy()
self.imgHud.destroy()
self.imgExp.destroy()
self.txtresultmission.setText("Mission: " + str(self.mission) +
" Complete")
if task.time > task.resultkills:
if self.resultcounter < self.destroyedenemy:
self.resultcounter += 1
self.txtresultkills.setText("Killed Enemies: " +
str(self.resultcounter))
self.CSound.sndTipp.play()
task.resultkills = task.time + 0.1
if self.resultcounter == self.destroyedenemy:
if task.time > task.resultleft:
if self.resultcounterleft < self.lostenemy:
self.resultcounterleft += 1
self.txtresultleft.setText(
"Left Enemies: " +
str(self.resultcounterleft))
task.resultleft = task.time + 0.1
self.CSound.sndTipp.play()
if self.resultcounterleft == self.lostenemy:
self.txtresultcash.setText(
"Geldstand: " + str(self.CActor.getMoney()) +
"$ (+" +
str(self.CActor.getMoney() - self.oldcash) +
"$)")
self.txtresultlevel.setText(
"Dein Level: " + str(self.CActor.getLevel()) +
" (+" + str(self.CActor.getLevel() -
self.oldactorlevel) + ")")
self.txtresultmessage.setText(
"Druecke Enter um fortzufahren")
if self.CActor.keyMap["entr"] != 0:
self.CActor.CActorShip.setShield(
self.maxshield)
self.CActor.setHP(self.CActor.getMaxHP())
taskMgr.remove('gameLoop')
self.CGame.request("GameMenue", self.CActor,
self.CGame)
if self.dead == True:
render.node().removeAllChildren()
taskMgr.remove("gameLoop")
self.CGame.request("MainMenue", self.CGame)
#Falls nextEnemyBullet-Timer NULL ist, so erstelle fuer jeden Gegner einen eigenen Timer
if (self.newwave == True):
for i in range(len(self.lenemys)):
task.lnextenemybullet.append(i)
self.newwave = False
#Gegnerfeuer erstellen und mit einem Zufallsalgorythmus schiessen lassen
for i in range(len(self.lenemys)):
posEnemyX = self.lenemys[i].CEnemyShip.getX()
#Erst schiessen lassen, wenn sie im Spielbereich sind
if posEnemyX < 170 and posEnemyX > -180 and self.lenemys[
i].nEnemyShip.hasParent() == True:
if task.time > task.lnextenemybullet[i]:
task.lnextenemybullet[i] = task.time + choice(
range(4, 7) + range(4, 7))
self.enemyShot(self.lenemys[i])
self.lenemys[i].CEnemyShip.getWeapon().sndGun.setVolume(
0.5)
self.lenemys[i].CEnemyShip.getWeapon().sndGun.play()
#Nachdem der Spieler die Schiesstaste gedrueckt hat, wird ein Timer aktiviert der nach eine Zeit
#immer wieder aktualisiert wird, damit der Spieler den naechsten Schuss abfeuern kann
if (self.CActor.keyMap["arr_up"] != 0 and task.time > task.nextbullet):
if self.dead == False:
task.nextbullet = task.time + 1.25**(-1.5 *
self.CActor.getAgility())
self.playerShot("laserGun")
self.CActor.CActorShip.getWeapon().sndGun.play()
#Nachdem der Spieler die Schiesstaste gedrueckt hat, wird ein Timer aktiviert der nach eine Zeit
#immer wieder aktualisiert wird, damit der Spieler den naechsten Schuss abfeuern kann
if (self.CActor.keyMap["arr_right"] != 0
and task.time > task.nextbullet):
if self.dead == False:
task.nextbullet = task.time + 1 + 1.25**(
-1.5 * self.CActor.getAgility())
self.playerShot("canonGun")
self.CActor.CActorShip.getWeapon().sndGun.play()
#Ein Array, um abgeschossen Patronen festzuhalten: vom Spieler
lnewbullet = []
#Funktion um die Bullets zu aktualsieren
for i in range(len(self.lbullets)):
self.updateBulletPlayer(self.lbullets[i], self.lbulletsspeed[i],
elapsed)
if self.lbullets[i].isEmpty() == 0:
if (self.lbullets[i].getX() < 180):
lnewbullet.append(self.lbullets[i])
else:
self.lbullets[i].remove()
self.lbullets = lnewbullet
lnewcanon = []
#Funktion um die Bullets zu aktualsieren
for i in range(len(self.lcanon)):
self.updateBulletPlayer(self.lcanon[i], self.lcanonspeed[i],
elapsed)
if self.lcanon[i].isEmpty() == 0:
if (self.lcanon[i].getX() < 180):
lnewcanon.append(self.lcanon[i])
else:
self.lcanon[i].remove()
self.lcanon = lnewcanon
#Ein Array, um abgeschossen Patronen festzuhalten: vom Gegner
lnewenemybullet = []
#Funktion um die Bullets der Gegner zu aktualsieren
for obj in self.lbulletsenemy:
self.updateBulletEnemy(obj, elapsed)
if obj.isEmpty() == 0:
if (obj.getX() > -180):
lnewenemybullet.append(obj)
else:
obj.remove()
self.lbulletsenemy = lnewenemybullet
#Funktion fuer die Kollision mit dem Gegner
for obj in self.lbullets:
self.enemyHit(obj)
for obj in self.lcanon:
self.enemyHit(obj)
#Funktion fuer die Kollision mit dem Spieler
if self.playerHit() == True:
self.hitted = True
#Funktion fuer die Kollision mit dem Schiff
if self.getShipHit() == True:
self.hitted = True
self.dropHit()
#Falls Spieler getroffen wird, so mache ein Cameraeffekt
if self.hitted == True:
if self.CActor.CActorShip.getShield() > 0:
self.cameraeffectamplitude = 5
base.camera.setZ(base.camera.getZ() +
self.cameraeffectamplitude *
math.sin(self.cameraeffectx))
self.cameraeffectx = self.cameraeffectx + 1
if self.cameraeffectx == 20:
self.hitted = False
self.cameraeffectx = 0
base.camera.setZ(0)
else:
if (self.dead == False):
self.cameraeffectamplitude = 2
base.camera.setZ(base.camera.getZ() +
self.cameraeffectamplitude *
math.sin(self.cameraeffectx))
self.cameraeffectx = self.cameraeffectx + 1
else:
self.hitted = False
for obj in self.ldrop:
if obj != None:
if obj.isEmpty() == 0:
obj.setHpr(obj.getH() - 1, 0, 0)
for obj in self.lexplosions:
if obj != None:
if obj.isEmpty() == 0:
posy = obj.getZ()
self.updateExplosion(
obj, elapsed, -3,
choice(range(-11, 11) + range(-11, 11)))
if obj.getX() < -180:
obj.remove()
return Task.cont
def updateExplosion(self, obj, dt, x, y):
if obj.isEmpty() == 0:
newposx = obj.getX() + (self.slowdown * dt * 35 * 3) * x
newposy = obj.getZ() + (self.slowdown * dt * 35 * 3) * y
obj.setX(newposx)
obj.setZ(newposy)
def updateBulletPlayer(self, obj, spe, dt):
if obj.isEmpty() == 0:
newpos = obj.getX() + (self.slowdown * dt * 35 * spe)
obj.setX(newpos)
def updateBulletEnemy(self, obj, dt):
if obj.isEmpty() == 0:
newpos = obj.getX() - (
self.slowdown * dt * 35 *
self.CEnemy.CEnemyShip.getWeapon().getWeaponSpeed())
obj.setX(newpos)
def updatePosEnemy(self, obj, dt):
if obj.nEnemyShip.isEmpty() == 0:
obj.CEnemyShip.setX(obj.CEnemyShip.getX() - self.slowdown * dt *
15 * obj.CEnemyShip.getSpeed())
obj.CEnemyShip.setY(obj.CEnemyShip.getY() +
self.slowdown * dt * 15 *
(math.sin(0.1 * obj.CEnemyShip.getX())))
def playerShot(self, gun):
bullet = self.CActor.CActorShip.getWeapon().setWeapon(gun)
if bullet.isEmpty() == 0:
if self.secweapon == 3:
bullet.setPos(self.CActor.CActorShip.getX() + 10, 500,
self.CActor.CActorShip.getY() + self.secweapon)
self.secweapon = -4
else:
bullet.setPos(self.CActor.CActorShip.getX() + 10, 500,
self.CActor.CActorShip.getY() + self.secweapon)
self.secweapon = 3
print self.CActor.CActorShip.getWeapon().getWeapon()
if self.CActor.CActorShip.getWeapon().getWeapon() == "laserGun":
self.lbullets.append(bullet)
self.lbulletsspeed.append(
self.CActor.CActorShip.getWeapon().getWeaponSpeed())
elif self.CActor.CActorShip.getWeapon().getWeapon() == "canonGun":
self.lcanon.append(bullet)
self.lcanonspeed.append(
self.CActor.CActorShip.getWeapon().getWeaponSpeed())
del bullet
def enemyShot(self, obj):
bullet = obj.CEnemyShip.getWeapon().setWeapon("laserGun")
if obj.nEnemyShip.isEmpty() == 0:
bullet.setPos(obj.nEnemyShip.getPos())
self.lbulletsenemy.append(bullet)
del bullet
def addDrop(self, pos):
drp = self.CEffects.getDrop("models/heal", 19, pos)
if (drp == None):
return False
else:
self.ldrop.append(drp)
return True
def explode(self, pos):
expl = self.CEffects.getExplosion(pos)
self.lexplosions.append(expl)
def enemyHit(self, bullet):
for enmy in self.lenemys:
if enmy.nEnemyShip.isEmpty() == 0 and bullet.isEmpty() == 0:
#Falls Gegner getroffen wird
if (bullet.getPos() -
enmy.nEnemyShip.getPos()).lengthSquared() < 85:
#Bullet loesche
bullet.remove()
self.explode(enmy.nEnemyShip.getPos())
enmy.CEnemyShip.setShield(
enmy.CEnemyShip.getShield() -
self.CActor.CActorShip.getWeapon().getWeaponStrength())
self.CSound.sndHit.play()
#Falls kein Schild mehr vorhanden -> Loeschen
if enmy.CEnemyShip.getShield() <= 0:
self.addDrop(enmy.nEnemyShip.getPos())
for i in range(5):
self.explode(enmy.nEnemyShip.getPos())
enmy.nEnemyShip.removeNode()
self.CSound.sndExplosion.play()
self.destroyedenemy += 1
self.CActor.setExperience(self.CActor.getExperience() +
(enmy.getExpDrop()))
self.exppercent = (self.CActor.getExperience() * 100
) / self.CActor.getMaxExperience()
if self.imgExp.isEmpty() == 0:
self.imgExp.setScale(
0.01, 0.2, ((2.0 * self.exppercent) / 100.0))
self.CActor.setMoney(self.CActor.getMoney() +
enmy.getCashDrop())
if self.CActor.getLevelUp() == True:
self.txtlvl.setText(str(self.CActor.getLevel()))
self.CActor.setExperience(self.CActor.getExperience() +
(enmy.getExpDrop() / 2))
self.exppercent = (self.CActor.getExperience() * 100
) / self.CActor.getMaxExperience()
self.imgExp.setScale(0.01, 0.2, 0.002)
def playerHit(self):
for bullet in self.lbulletsenemy:
if self.CActor.nActorShip.isEmpty() == 0 and bullet.isEmpty() == 0:
#Falls Spieler getroffen wird
if ((bullet.getPos() -
self.CActor.nActorShip.getPos()).lengthSquared() < 85):
#Bullet loeschen
bullet.remove()
#Funktion aufrufen - Parameter: Schaden
if self.actorHurt(self.CEnemy.CEnemyShip.getWeapon(
).getWeaponStrength() + self.CEnemy.getStrength()) == True:
return True
def getShipHit(self):
for enmy in self.lenemys:
if enmy.nEnemyShip.isEmpty(
) == 0 and self.CActor.nActorShip.isEmpty() == 0:
#Falls das Spielerschiff einen Gegnerschiff trifft
if ((enmy.nEnemyShip.getPos() -
self.CActor.nActorShip.getPos()).lengthSquared() < 85):
for i in range(5):
self.explode(enmy.nEnemyShip.getPos())
enmy.nEnemyShip.removeNode()
#self.CSound.sndExplosion.play()
self.destroyedenemy += 1
self.CActor.setExperience(self.CActor.getExperience() +
(enmy.getExpDrop() / 2))
self.exppercent = (self.CActor.getExperience() *
100) / self.CActor.getMaxExperience()
if self.CActor.getLevelUp() == True:
self.txtlvl.setText(str(self.CActor.getLevel()))
self.CActor.setExperience(self.CActor.getExperience() +
(enmy.getExpDrop() / 2))
self.exppercent = (self.CActor.getExperience() * 100
) / self.CActor.getMaxExperience()
#Schaden ist gleich der Staerke vom gegnerischen Schiff
if self.actorHurt(enmy.getStrength()) == True:
return True
def createEnemys(self, amount, kind):
for i in range(amount):
#Gegner erstellen
self.CEnemy = Enemy(kind)
self.lenemys.append(self.CEnemy)
def spawnEnemys(self, start, width):
for obj in self.lenemys:
if obj.CEnemyShip.getY() > 101 and obj.nEnemyShip.isEmpty() == 0:
obj.CEnemyShip.setX(
choice(range(start, width) + range(start, width)))
obj.CEnemyShip.setY(choice(range(-100, 0) + range(0, 100)))
self.newwave = True
def dropHit(self):
for obj in self.ldrop:
if obj.isEmpty() == 0 and self.CActor.nActorShip.isEmpty() == 0:
if ((obj.getPos() -
self.CActor.nActorShip.getPos()).lengthSquared() < 86):
obj.remove()
if self.CActor.getHP() < self.CActor.getMaxHP():
self.CActor.setHP(self.CActor.getHP() + 20)
self.txthp.setText(
str((self.CActor.getHP() * 100) /
self.CActor.getMaxHP()))
def actorHurt(self, dmg):
if (self.CActor.CActorShip.getShield() <= 0):
self.txtshield.setText("0")
self.CActor.CActorShip.setShield(0)
self.CActor.setHP(self.CActor.getHP() - dmg * 20)
self.CSound.sndCrit.play()
if (self.CActor.getHP() <= 0):
#Der Spieler ist tot und hat verloren
self.txthp.setText("0")
self.dead = True
#self.CFilters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=5.0, size="small")
self.slowdown = 1
self.CActor.slowdown = self.slowdown
taskMgr.remove("takeSnapShot")
self.clickrate = 0
self.fcard.hide()
for i in range(5):
self.explode(self.CActor.nActorShip.getPos())
self.CActor.nActorShip.detachNode()
return True
if (self.CActor.getHP() <= 50):
self.CSound.sndExplosion.setPlayRate(0.5)
self.CSound.sndMusic.setPlayRate(0.5)
self.CSound.sndFlyAmbience.setPlayRate(0.5)
self.CSound.sndHit.setPlayRate(0.5)
self.CActor.CActorShip.getWeapon().sndGun.setPlayRate(0.5)
taskMgr.add(self.takeSnapShot, "takeSnapShot")
self.chooseEffectGhost()
self.slowdown = 0.5
self.CActor.setSlowDown(self.slowdown)
#self.CFilters.delBloom()
self.explode(self.CActor.nActorShip.getPos())
self.txthp.setText(
str((self.CActor.getHP() * 100) / self.CActor.getMaxHP()))
return True
else:
self.CActor.CActorShip.setShield(
self.CActor.CActorShip.getShield() - dmg)
self.txtshield.setText(
str((self.CActor.CActorShip.getShield() * 100) /
self.maxshield))
self.explode(self.CActor.nActorShip.getPos())
return True
#Screenshots erstellen um MotionBlur Effekt zu erreichen
def takeSnapShot(self, task):
if (task.time > self.nextclick):
self.nextclick += 1.0 / self.clickrate
if (self.nextclick < task.time):
self.nextclick = task.time
base.win.triggerCopy()
return Task.cont
#MotionBlur Effekt
def chooseEffectGhost(self):
base.setBackgroundColor(0, 0, 0, 1)
self.bcard.hide()
self.fcard.show()
self.fcard.setColor(1.0, 1.0, 1.0, 0.99)
self.fcard.setScale(1.00)
self.fcard.setPos(0, 0, 0)
self.fcard.setR(0)
self.clickrate = 100
self.nextclick = 0
def toogleHud(self):
if self.hud == False:
#Hudeinstellung *******************************************************************************
self.imgHud = OnscreenImage(image='images/hud.png',
pos=(-1.09, 0, -0.01),
scale=(0.185, 0.5, 1))
self.imgHud.reparentTo(aspect2d)
self.imgHud.setTransparency(TransparencyAttrib.MAlpha)
#EXP Leiste
self.imgExp = OnscreenImage(image='images/exp.png',
pos=(-1.2645, 0, -1),
scale=(0.01, 0.2, 0.001))
self.imgExp.reparentTo(aspect2d)
#Texte der HUD
self.txthp = addText(
-1.03, 0.966,
str((self.CActor.getHP() * 100) / self.CActor.getMaxHP()))
self.txtshield = addText(
-1.03, 0.9151,
str((self.CActor.CActorShip.getShield() * 100) /
self.maxshield))
self.txtlvl = addText(-1.19, 0.80, str(self.CActor.getLevel()))
self.hud = True
class HtmlView(DirectObject):
notify = DirectNotifyGlobal.directNotify.newCategory('HtmlView')
useHalfTexture = config.GetBool('news-half-texture', 0)
def __init__(self, parent = aspect2d):
global GlobalWebcore
self.parent = parent
self.mx = 0
self.my = 0
self.htmlFile = 'index.html'
self.transparency = False
if GlobalWebcore:
pass
else:
GlobalWebcore = AwWebCore(AwWebCore.LOGVERBOSE, True, AwWebCore.PFBGRA)
GlobalWebcore.setBaseDirectory('.')
for errResponse in xrange(400, 600):
GlobalWebcore.setCustomResponsePage(errResponse, 'error.html')
self.webView = GlobalWebcore.createWebView(WEB_WIDTH, WEB_HEIGHT, self.transparency, False, 70)
frameName = ''
inGameNewsUrl = self.getInGameNewsUrl()
self.imgBuffer = array.array('B')
for i in xrange(WEB_WIDTH * WEB_HEIGHT):
self.imgBuffer.append(0)
self.imgBuffer.append(0)
self.imgBuffer.append(0)
self.imgBuffer.append(255)
if self.useHalfTexture:
self.leftBuffer = array.array('B')
for i in xrange(WEB_HALF_WIDTH * WEB_HEIGHT):
self.leftBuffer.append(0)
self.leftBuffer.append(0)
self.leftBuffer.append(0)
self.leftBuffer.append(255)
self.rightBuffer = array.array('B')
for i in xrange(WEB_HALF_WIDTH * WEB_HEIGHT):
self.rightBuffer.append(0)
self.rightBuffer.append(0)
self.rightBuffer.append(0)
self.rightBuffer.append(255)
self.setupTexture()
if self.useHalfTexture:
self.setupHalfTextures()
self.accept('mouse1', self.mouseDown, [AwWebView.LEFTMOUSEBTN])
self.accept('mouse3', self.mouseDown, [AwWebView.RIGHTMOUSEBTN])
self.accept('mouse1-up', self.mouseUp, [AwWebView.LEFTMOUSEBTN])
self.accept('mouse3-up', self.mouseUp, [AwWebView.RIGHTMOUSEBTN])
def getInGameNewsUrl(self):
result = config.GetString('fallback-news-url', 'http://cdn.toontown.disney.go.com/toontown/en/gamenews/')
override = config.GetString('in-game-news-url', '')
if override:
self.notify.info('got an override url, using %s for in a game news' % override)
result = override
else:
try:
launcherUrl = base.launcher.getValue('GAME_IN_GAME_NEWS_URL', '')
if launcherUrl:
result = launcherUrl
self.notify.info('got GAME_IN_GAME_NEWS_URL from launcher using %s' % result)
else:
self.notify.info('blank GAME_IN_GAME_NEWS_URL from launcher, using %s' % result)
except:
self.notify.warning('got exception getting GAME_IN_GAME_NEWS_URL from launcher, using %s' % result)
return result
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 setupHalfTextures(self):
self.setupLeftTexture()
self.setupRightTexture()
self.fullPnmImage = PNMImage(WEB_WIDTH, WEB_HEIGHT, 4)
self.leftPnmImage = PNMImage(WEB_HALF_WIDTH, WEB_HEIGHT, 4)
self.rightPnmImage = PNMImage(WEB_HALF_WIDTH, WEB_HEIGHT, 4)
def setupLeftTexture(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)
cm.setFrame(-htmlWidth / 2.0, 0, -htmlHeight / 2.0, htmlHeight / 2.0)
card = cm.generate()
self.leftQuad = NodePath(card)
self.leftQuad.reparentTo(self.parent)
self.leftGuiTex = Texture('guiTex')
self.leftGuiTex.setupTexture(Texture.TT2dTexture, WEB_HALF_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba)
self.leftGuiTex.setKeepRamImage(True)
self.leftGuiTex.makeRamImage()
self.leftGuiTex.setWrapU(Texture.WMClamp)
self.leftGuiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('leftWebTS')
self.leftQuad.setTexture(ts, self.leftGuiTex)
self.leftQuad.setTexScale(ts, 1.0, -1.0)
self.leftQuad.setTransparency(0)
self.leftQuad.setTwoSided(True)
self.leftQuad.setColor(1.0, 1.0, 1.0, 1.0)
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)
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 calcMouseLimits(self):
ll = Point3()
ur = Point3()
self.quad.calcTightBounds(ll, ur)
self.notify.debug('ll=%s ur=%s' % (ll, ur))
offset = self.quad.getPos(aspect2d)
self.notify.debug('offset = %s ' % offset)
ll.setZ(ll.getZ() + offset.getZ())
ur.setZ(ur.getZ() + offset.getZ())
self.notify.debug('new LL=%s, UR=%s' % (ll, ur))
relPointll = self.quad.getRelativePoint(aspect2d, ll)
self.notify.debug('relPoint = %s' % relPointll)
self.mouseLL = (aspect2d.getScale()[0] * ll[0], aspect2d.getScale()[2] * ll[2])
self.mouseUR = (aspect2d.getScale()[0] * ur[0], aspect2d.getScale()[2] * ur[2])
self.notify.debug('original mouseLL=%s, mouseUR=%s' % (self.mouseLL, self.mouseUR))
def writeTex(self, filename = 'guiText.png'):
self.notify.debug('writing texture')
self.guiTex.generateRamMipmapImages()
self.guiTex.write(filename)
def toggleRotation(self):
if self.interval.isPlaying():
self.interval.finish()
else:
self.interval.loop()
def mouseDown(self, button):
messenger.send('wakeup')
self.webView.injectMouseDown(button)
def mouseUp(self, button):
self.webView.injectMouseUp(button)
def reload(self):
pass
def zoomIn(self):
self.webView.zoomIn()
def zoomOut(self):
self.webView.zoomOut()
def toggleTransparency(self):
self.transparency = not self.transparency
self.webView.setTransparent(self.transparency)
def update(self, task):
if base.mouseWatcherNode.hasMouse():
x, y = self._translateRelativeCoordinates(base.mouseWatcherNode.getMouseX(), base.mouseWatcherNode.getMouseY())
if self.mx - x != 0 or self.my - y != 0:
self.webView.injectMouseMove(x, y)
self.mx, self.my = x, y
if self.webView.isDirty():
self.webView.render(self.imgBuffer.buffer_info()[0], WEB_WIDTH * 4, 4)
Texture.setTexturesPower2(2)
textureBuffer = self.guiTex.modifyRamImage()
textureBuffer.setData(self.imgBuffer.tostring())
if self.useHalfTexture:
self.guiTex.store(self.fullPnmImage)
self.leftPnmImage.copySubImage(self.fullPnmImage, 0, 0, 0, 0, WEB_HALF_WIDTH, WEB_HEIGHT)
self.rightPnmImage.copySubImage(self.fullPnmImage, 0, 0, WEB_HALF_WIDTH, 0, WEB_HALF_WIDTH, WEB_HEIGHT)
self.leftGuiTex.load(self.leftPnmImage)
self.rightGuiTex.load(self.rightPnmImage)
self.quad.hide()
Texture.setTexturesPower2(1)
GlobalWebcore.update()
return Task.cont
def _translateRelativeCoordinates(self, x, y):
sx = int((x - self.mouseLL[0]) / (self.mouseUR[0] - self.mouseLL[0]) * WEB_WIDTH_PIXELS)
sy = WEB_HEIGHT_PIXELS - int((y - self.mouseLL[1]) / (self.mouseUR[1] - self.mouseLL[1]) * WEB_HEIGHT_PIXELS)
return (sx, sy)
def unload(self):
self.ignoreAll()
self.webView.destroy()
self.webView = None
return
def onCallback(self, name, args):
if name == 'requestFPS':
pass
def onBeginNavigation(self, url, frameName):
pass
def onBeginLoading(self, url, frameName, statusCode, mimeType):
pass
def onFinishLoading(self):
self.notify.debug('finished loading')
def onReceiveTitle(self, title, frameName):
pass
def onChangeTooltip(self, tooltip):
pass
def onChangeCursor(self, cursor):
pass
def onChangeKeyboardFocus(self, isFocused):
pass
def onChangeTargetURL(self, url):
pass
class HtmlView(DirectObject):
notify = DirectNotifyGlobal.directNotify.newCategory("HtmlView")
useHalfTexture = base.config.GetBool("news-half-texture", 0)
def __init__(self, parent=aspect2d):
"""Properly initialize ourself."""
#AwWebViewListener.AwWebViewListener.__init__(self)
self.parent = parent
self.mx = 0
self.my = 0
self.htmlFile = "index.html"
self.transparency = False # this is important looks weird if it's true
global GlobalWebcore
if GlobalWebcore:
# we get a C++ crash if we construct webcore a second time
pass
else:
GlobalWebcore = AwWebCore(AwWebCore.LOGVERBOSE, True,
AwWebCore.PFBGRA)
GlobalWebcore.setBaseDirectory('.')
for errResponse in xrange(400, 600):
GlobalWebcore.setCustomResponsePage(errResponse, "error.html")
self.webView = GlobalWebcore.createWebView(WEB_WIDTH, WEB_HEIGHT,
self.transparency, False,
70)
#self.webView.setListener(self)
#self.webView.setCallback("requestFPS");
frameName = ''
inGameNewsUrl = self.getInGameNewsUrl()
#self.webView.loadURL2(inGameNewsUrl)
self.imgBuffer = array.array('B')
for i in xrange(WEB_WIDTH * WEB_HEIGHT):
self.imgBuffer.append(0)
self.imgBuffer.append(0)
self.imgBuffer.append(0)
self.imgBuffer.append(255)
if self.useHalfTexture:
self.leftBuffer = array.array('B')
for i in xrange(WEB_HALF_WIDTH * WEB_HEIGHT):
self.leftBuffer.append(0)
self.leftBuffer.append(0)
self.leftBuffer.append(0)
self.leftBuffer.append(255)
self.rightBuffer = array.array('B')
for i in xrange(WEB_HALF_WIDTH * WEB_HEIGHT):
self.rightBuffer.append(0)
self.rightBuffer.append(0)
self.rightBuffer.append(0)
self.rightBuffer.append(255)
self.setupTexture()
if self.useHalfTexture:
self.setupHalfTextures()
#self.interval = LerpHprInterval(self.quad, 2, Vec3(360, 0, 0), Vec3(0, 0, 0))
#self.accept("escape", sys.exit, [0])
#self.accept("w", self.writeTex)
self.accept("mouse1", self.mouseDown, [AwWebView.LEFTMOUSEBTN])
self.accept("mouse3", self.mouseDown, [AwWebView.RIGHTMOUSEBTN])
self.accept("mouse1-up", self.mouseUp, [AwWebView.LEFTMOUSEBTN])
self.accept("mouse3-up", self.mouseUp, [AwWebView.RIGHTMOUSEBTN])
#self.accept("f1", self.toggleRotation)
#self.accept("f2", self.toggleTransparency)
#self.accept("f3", self.reload)
#self.accept("f4", self.zoomIn)
#self.accept("f5", self.zoomOut)
#taskMgr.doMethodLater(1.0, self.update, 'HtmlViewUpdateTask')
# we get a problem if a mid-frame hearbeat fires of this task in conjunction with igLoop
#taskMgr.add(self.update, 'HtmlViewUpdateTask', priority = 51)
#taskMgr.add(self.update, 'HtmlViewUpdateTask')
#base.newsFrame = self
def getInGameNewsUrl(self):
"""Get the appropriate URL to use if we are in test, qa, or live."""
# First if all else fails, we hard code the live news url
result = base.config.GetString(
"fallback-news-url",
"http://cdn.toontown.disney.go.com/toontown/en/gamenews/")
# next check if we have an override, say they want to url to point to a file in their harddisk
override = base.config.GetString("in-game-news-url", "")
if override:
self.notify.info(
"got an override url, using %s for in a game news" % override)
result = override
else:
try:
launcherUrl = base.launcher.getValue("GAME_IN_GAME_NEWS_URL",
"")
if launcherUrl:
result = launcherUrl
self.notify.info(
"got GAME_IN_GAME_NEWS_URL from launcher using %s" %
result)
else:
self.notify.info(
"blank GAME_IN_GAME_NEWS_URL from launcher, using %s" %
result)
except:
self.notify.warning(
"got exception getting GAME_IN_GAME_NEWS_URL from launcher, using %s"
% result)
return result
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)
# 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()
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.quad.setZ(0.1) # shtickerbook is moved up by 0.1
self.calcMouseLimits()
def setupHalfTextures(self):
self.setupLeftTexture()
self.setupRightTexture()
self.fullPnmImage = PNMImage(WEB_WIDTH, WEB_HEIGHT, 4)
self.leftPnmImage = PNMImage(WEB_HALF_WIDTH, WEB_HEIGHT, 4)
self.rightPnmImage = PNMImage(WEB_HALF_WIDTH, WEB_HEIGHT, 4)
def setupLeftTexture(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(-htmlWidth / 2.0, 0, -htmlHeight / 2.0, htmlHeight / 2.0)
card = cm.generate()
self.leftQuad = NodePath(card)
self.leftQuad.reparentTo(self.parent)
self.leftGuiTex = Texture("guiTex")
self.leftGuiTex.setupTexture(Texture.TT2dTexture, WEB_HALF_WIDTH,
WEB_HEIGHT, 1, Texture.TUnsignedByte,
Texture.FRgba)
self.leftGuiTex.setKeepRamImage(True)
self.leftGuiTex.makeRamImage()
self.leftGuiTex.setWrapU(Texture.WMClamp)
self.leftGuiTex.setWrapV(Texture.WMClamp)
ts = TextureStage('leftWebTS')
self.leftQuad.setTexture(ts, self.leftGuiTex)
self.leftQuad.setTexScale(ts, 1.0, -1.0)
self.leftQuad.setTransparency(0)
self.leftQuad.setTwoSided(True)
self.leftQuad.setColor(1.0, 1.0, 1.0, 1.0)
#self.quad.setZ(0.1) # shtickerbook is moved up by 0.1
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)
#self.quad.setZ(0.1) # shtickerbook is moved up by 0.1
def calcMouseLimits(self):
ll = Point3()
ur = Point3()
self.quad.calcTightBounds(ll, ur)
self.notify.debug("ll=%s ur=%s" % (ll, ur))
# we need to get our relative position to aspect2d, since shtiker books is shifted
offset = self.quad.getPos(aspect2d)
self.notify.debug("offset = %s " % offset)
ll.setZ(ll.getZ() + offset.getZ())
ur.setZ(ur.getZ() + offset.getZ())
self.notify.debug("new LL=%s, UR=%s" % (ll, ur))
relPointll = self.quad.getRelativePoint(aspect2d, ll)
self.notify.debug("relPoint = %s" % relPointll)
self.mouseLL = (aspect2d.getScale()[0] * ll[0],
aspect2d.getScale()[2] * ll[2])
self.mouseUR = (aspect2d.getScale()[0] * ur[0],
aspect2d.getScale()[2] * ur[2])
self.notify.debug("original mouseLL=%s, mouseUR=%s" %
(self.mouseLL, self.mouseUR))
def writeTex(self, filename="guiText.png"):
self.notify.debug("writing texture")
self.guiTex.generateRamMipmapImages()
self.guiTex.write(filename)
def toggleRotation(self):
if self.interval.isPlaying():
self.interval.finish()
else:
self.interval.loop()
def mouseDown(self, button):
messenger.send('wakeup')
self.webView.injectMouseDown(button)
def mouseUp(self, button):
self.webView.injectMouseUp(button)
def reload(self):
pass
#self.webView.loadFile(self.htmlFile, '')
def zoomIn(self):
self.webView.zoomIn()
def zoomOut(self):
self.webView.zoomOut()
def toggleTransparency(self):
self.transparency = not self.transparency
self.webView.setTransparent(self.transparency)
def update(self, task):
global GlobalWebcore
if base.mouseWatcherNode.hasMouse():
x, y = self._translateRelativeCoordinates(
base.mouseWatcherNode.getMouseX(),
base.mouseWatcherNode.getMouseY())
#self.notify.debug('got mouse move %d %d' % (x,y))
#self.webView.injectMouseMove(x, y)
if (self.mx - x) != 0 or (self.my - y) != 0:
self.webView.injectMouseMove(x, y)
#self.notify.debug('injecting mouse move %d %d' % (x,y))
self.mx, self.my = x, y
if self.webView.isDirty():
#self.notify.debug("webview is dirty")
self.webView.render(self.imgBuffer.buffer_info()[0],
WEB_WIDTH * 4, 4)
#Texture.setTexturesPower2(AutoTextureScale.ATSUp)
Texture.setTexturesPower2(2)
#self.notify.debug("about to modify ram image")
textureBuffer = self.guiTex.modifyRamImage()
#import pdb; pdb.set_trace()
#self.notify.debug("about to call textureBuffer.setData")
textureBuffer.setData(self.imgBuffer.tostring())
#self.notify.debug("done calling setData")
if self.useHalfTexture:
# TODO check with DRose, this feels inefficient
self.guiTex.store(self.fullPnmImage)
self.leftPnmImage.copySubImage(self.fullPnmImage, 0, 0, 0,
0, WEB_HALF_WIDTH,
WEB_HEIGHT)
self.rightPnmImage.copySubImage(self.fullPnmImage, 0, 0,
WEB_HALF_WIDTH, 0,
WEB_HALF_WIDTH, WEB_HEIGHT)
self.leftGuiTex.load(self.leftPnmImage)
self.rightGuiTex.load(self.rightPnmImage)
self.quad.hide()
#Texture.setTexturesPower2(AutoTextureScale.ATSDown)
Texture.setTexturesPower2(1)
GlobalWebcore.update()
return Task.cont
def _translateRelativeCoordinates(self, x, y):
sx = int((x - self.mouseLL[0]) / (self.mouseUR[0] - self.mouseLL[0]) *
WEB_WIDTH_PIXELS)
sy = WEB_HEIGHT_PIXELS - int(
(y - self.mouseLL[1]) /
(self.mouseUR[1] - self.mouseLL[1]) * WEB_HEIGHT_PIXELS)
return sx, sy
def unload(self):
"""Clean up everything, especially the awesomium bits."""
self.ignoreAll()
self.webView.destroy()
self.webView = None
#global GlobalWebcore
#GlobalWebcore = None
pass
# --------------------[ WebViewListener implementation ]--------------------------
def onCallback(self, name, args):
assert self.notify.debugStateCall(self)
if name == "requestFPS":
#self.webView.setProperty( "fps", JSValue("%.1f" % (1.0 / globalClock.getDt())) )
#self.webView.executeJavascript("updateFPS()", "")
pass
def onBeginNavigation(self, url, frameName):
assert self.notify.debugStateCall(self)
pass
def onBeginLoading(self, url, frameName, statusCode, mimeType):
assert self.notify.debugStateCall(self)
pass
def onFinishLoading(self):
assert self.notify.debugStateCall(self)
self.notify.debug("finished loading")
pass
def onReceiveTitle(self, title, frameName):
assert self.notify.debugStateCall(self)
pass
def onChangeTooltip(self, tooltip):
assert self.notify.debugStateCall(self)
pass
def onChangeCursor(self, cursor):
assert self.notify.debugStateCall(self)
pass
def onChangeKeyboardFocus(self, isFocused):
assert self.notify.debugStateCall(self)
pass
def onChangeTargetURL(self, url):
assert self.notify.debugStateCall(self)
pass