def renderQuadInto(self,
                       mul=1,
                       div=1,
                       align=1,
                       depthtex=None,
                       colortex=None,
                       auxtex0=None,
                       auxtex1=None):
        texgroup = (depthtex, colortex, auxtex0, auxtex1)
        (winx, winy) = self.getScaledSize(mul, div, align)
        depthbits = bool(depthtex != None)
        buffer = self.createBuffer('filter-stage', winx, winy, texgroup,
                                   depthbits)
        if buffer == None:
            return None

        cm = CardMaker('filter-stage-quad')
        cm.setFrameFullscreenQuad()
        quad = NodePath(cm.generate())
        quad.setDepthTest(0)
        quad.setDepthWrite(0)
        quad.setColor(Vec4(1, 0.5, 0.5, 1))
        quadcamnode = Camera('filter-quad-cam')
        lens = OrthographicLens()
        lens.setFilmSize(2, 2)
        lens.setFilmOffset(0, 0)
        lens.setNearFar(-1000, 1000)
        quadcamnode.setLens(lens)
        quadcam = quad.attachNewNode(quadcamnode)
        buffer.getDisplayRegion(0).setCamera(quadcam)
        buffer.getDisplayRegion(0).setActive(1)
        self.buffers.append(buffer)
        self.sizes.append((mul, div, align))
        return quad
    def renderSceneInto(self,
                        depthtex=None,
                        colortex=None,
                        auxtex=None,
                        auxbits=0,
                        textures=None):
        if textures:
            colortex = textures.get('color', None)
            depthtex = textures.get('depth', None)
            auxtex = textures.get('aux', None)

        if colortex == None:
            colortex = Texture('filter-base-color')
            colortex.setWrapU(Texture.WMClamp)
            colortex.setWrapV(Texture.WMClamp)

        texgroup = (depthtex, colortex, auxtex, None)
        (winx, winy) = self.getScaledSize(1, 1, 1)
        buffer = self.createBuffer('filter-base', winx, winy, texgroup)
        if buffer == None:
            return None

        cm = CardMaker('filter-base-quad')
        cm.setFrameFullscreenQuad()
        quad = NodePath(cm.generate())
        quad.setDepthTest(0)
        quad.setDepthWrite(0)
        quad.setTexture(colortex)
        quad.setColor(Vec4(1, 0.5, 0.5, 1))
        cs = NodePath('dummy')
        cs.setState(self.camstate)
        if auxbits:
            cs.setAttrib(AuxBitplaneAttrib.make(auxbits))

        self.camera.node().setInitialState(cs.getState())
        quadcamnode = Camera('filter-quad-cam')
        lens = OrthographicLens()
        lens.setFilmSize(2, 2)
        lens.setFilmOffset(0, 0)
        lens.setNearFar(-1000, 1000)
        quadcamnode.setLens(lens)
        quadcam = quad.attachNewNode(quadcamnode)
        self.region.setCamera(quadcam)
        dr = buffer.getDisplayRegion(0)
        self.setStackedClears(dr, self.rclears, self.wclears)
        if auxtex:
            dr.setClearActive(GraphicsOutput.RTPAuxRgba0, 1)
            dr.setClearValue(GraphicsOutput.RTPAuxRgba0,
                             Vec4(0.5, 0.5, 1.0, 0.0))

        self.region.disableClears()
        if self.isFullscreen():
            self.win.disableClears()

        dr.setCamera(self.camera)
        dr.setActive(1)
        self.buffers.append(buffer)
        self.sizes.append((1, 1, 1))
        return quad
Пример #3
0
    def renderQuadInto(self,
                       mul=1,
                       div=1,
                       align=1,
                       depthtex=None,
                       colortex=None,
                       auxtex0=None,
                       auxtex1=None):
        """ Creates an offscreen buffer for an intermediate
        computation. Installs a quad into the buffer.  Returns
        the fullscreen quad.  The size of the buffer is initially
        equal to the size of the main window.  The parameters 'mul',
        'div', and 'align' can be used to adjust that size. """

        texgroup = (depthtex, colortex, auxtex0, auxtex1)

        winx, winy = self.getScaledSize(mul, div, align)

        depthbits = bool(depthtex != None)

        buffer = self.createBuffer("filter-stage", winx, winy, texgroup,
                                   depthbits)

        if (buffer == None):
            return None

        cm = CardMaker("filter-stage-quad")
        cm.setFrameFullscreenQuad()
        quad = NodePath(cm.generate())
        quad.setDepthTest(0)
        quad.setDepthWrite(0)
        quad.setColor(Vec4(1, 0.5, 0.5, 1))

        quadcamnode = Camera("filter-quad-cam")
        lens = OrthographicLens()
        lens.setFilmSize(2, 2)
        lens.setFilmOffset(0, 0)
        lens.setNearFar(-1000, 1000)
        quadcamnode.setLens(lens)
        quadcam = quad.attachNewNode(quadcamnode)

        dr = buffer.makeDisplayRegion((0, 1, 0, 1))
        dr.disableClears()
        dr.setCamera(quadcam)
        dr.setActive(True)
        dr.setScissorEnabled(False)

        # This clear stage is important if the buffer is padded, so that
        # any pixels accidentally sampled in the padded region won't
        # be reading from unititialised memory.
        buffer.setClearColor((0, 0, 0, 1))
        buffer.setClearColorActive(True)

        self.buffers.append(buffer)
        self.sizes.append((mul, div, align))

        return quad
Пример #4
0
    def createSprite(self, sprite):
        '''
        Creates a new sprite and returns a SpriteRenderInterface for controlling this sprite instance.
        The newly created sprite is located at (0,0) in screen coordinates its dimensions are specified
        by the given Sprite argument.
        @param sprite: A Sprite resource that describes the properties of the sprite to created.
        @return: A SpriteRenderInterface instance or None if it failed to create the sprite.
        '''
        if sprite.eggFile is not None:
            spriteNP = self.resources.loadModel(sprite.eggFile)
            tex = None
        else:
            if sprite.video is not None:
                card = self.cardMaker.generate()
                tex = VideoPlayer.renderToTexture(self.resources,
                                                  video=sprite.video,
                                                  audio=sprite.audio)
            elif sprite.image is not None:
                card = self.cardMaker.generate()
                tex = self.resources.loadTexture(sprite.image)
                sprite.width = tex.getXSize()
                sprite.height = tex.getYSize()
            else:
                self.log.error('Could not determine type for sprite: %s' %
                               sprite.name)
                return None

            spriteNP = NodePath(card)
            spriteNP.setTexture(tex)

        nodeName = self.getSpriteNodeName(sprite.name)
        spriteNP.setName(nodeName)
        spriteNP.setPos(0, 1, 0)
        spriteNP.setScale(sprite.width, 1.0, sprite.height)
        spriteNP.setTransparency(1)

        spriteNP.reparentTo(self.sprite2d)

        spriteNP.setDepthTest(False)
        spriteNP.setDepthWrite(False)
        spriteNP.setBin("fixed", PanoConstants.RENDER_ORDER_SPRITES)
        spriteNP.setPythonTag('sprite', sprite)

        if sprite.video is not None:
            spriteNP.setPythonTag('video', tex)
            tex.setLoop(True)
            tex.play()

        return SpriteRenderInterface(spriteNP)
Пример #5
0
def setSky(directory, ext=".jpg"):
    """Sets up a skybox. 'directory' is the directory whitch contains 6
    pictures with the names right.ext, left.ext and so on (see template).
    ext is the extension the pictures have (with dot).
    """
    #TODO: accept all supported image file extensions without the need for an
    #      extra argument

    # remove the old sky first when loading a new one
    # TODO: get this working...
    #oldsky = render.find("*sky*")
    #print oldsky
    #for child in render.getChildren():
    #    child.remove()

    sky = NodePath().attachNewNode("sky")
    sides = {
        "right":  ( 1,  0,  0, -90,   0,  0),
        "left":   (-1,  0,  0,  90,   0,  0),
        "top":    ( 0,  0,  1,   0,  90,  0),
        "bottom": ( 0,  0, -1,  180,  -90,  0),
        "front":  ( 0,  1,  0,   0,   0,  0),
        "back":   ( 0, -1,  0, 180,   0,  0)
        }
    for name, poshpr in sides.iteritems():

        c = CardMaker(name)
        c.setFrame(-1, 1, -1, 1)
        card = c.generate()
        cardnode = sky.attachNewNode(card)
        cardnode.setPosHpr(*poshpr)
        tex = loader.loadTexture("skyboxes/" + directory + "/" + name + ext)
        tex.setWrapV(tex.WMClamp)
        tex.setMagfilter(tex.FTNearestMipmapNearest)
        tex.setMinfilter(tex.FTNearestMipmapNearest)
        cardnode.setTexture(tex)

    sky.flattenStrong()
    sky.setScale(10, 10, 10)
    sky.setCompass()
    sky.setBin('background', 0)
    sky.setDepthTest(False)
    sky.setDepthWrite(False)
    sky.setLightOff()
    sky.reparentTo(camera)

    geom = sky.getChild(0).node()
    geom.setName("cube")
    def renderQuadInto(self,
                       mul=1,
                       div=1,
                       align=1,
                       depthtex=None,
                       colortex=None,
                       auxtex0=None,
                       auxtex1=None):
        """ Creates an offscreen buffer for an intermediate
        computation. Installs a quad into the buffer.  Returns
        the fullscreen quad.  The size of the buffer is initially
        equal to the size of the main window.  The parameters 'mul',
        'div', and 'align' can be used to adjust that size. """

        texgroup = (depthtex, colortex, auxtex0, auxtex1)

        winx, winy = self.getScaledSize(mul, div, align)

        depthbits = bool(depthtex != None)

        buffer = self.createBuffer("filter-stage", winx, winy, texgroup,
                                   depthbits)

        if (buffer == None):
            return None

        cm = CardMaker("filter-stage-quad")
        cm.setFrameFullscreenQuad()
        quad = NodePath(cm.generate())
        quad.setDepthTest(0)
        quad.setDepthWrite(0)
        quad.setColor(Vec4(1, 0.5, 0.5, 1))

        quadcamnode = Camera("filter-quad-cam")
        lens = OrthographicLens()
        lens.setFilmSize(2, 2)
        lens.setFilmOffset(0, 0)
        lens.setNearFar(-1000, 1000)
        quadcamnode.setLens(lens)
        quadcam = quad.attachNewNode(quadcamnode)

        buffer.getDisplayRegion(0).setCamera(quadcam)
        buffer.getDisplayRegion(0).setActive(1)

        self.buffers.append(buffer)
        self.sizes.append((mul, div, align))

        return quad
Пример #7
0
    def renderQuadInto(self, mul=1, div=1, align=1, depthtex=None, colortex=None, auxtex0=None, auxtex1=None):

        """ Creates an offscreen buffer for an intermediate
        computation. Installs a quad into the buffer.  Returns
        the fullscreen quad.  The size of the buffer is initially
        equal to the size of the main window.  The parameters 'mul',
        'div', and 'align' can be used to adjust that size. """

        texgroup = (depthtex, colortex, auxtex0, auxtex1)

        winx, winy = self.getScaledSize(mul, div, align)
        
        depthbits = bool(depthtex != None)
        
        buffer = self.createBuffer("filter-stage", winx, winy, texgroup, depthbits)

        if (buffer == None):
            return None

        cm = CardMaker("filter-stage-quad")
        cm.setFrameFullscreenQuad()
        quad = NodePath(cm.generate())
        quad.setDepthTest(0)
        quad.setDepthWrite(0)
        quad.setColor(Vec4(1,0.5,0.5,1))

        quadcamnode = Camera("filter-quad-cam")
        lens = OrthographicLens()
        lens.setFilmSize(2, 2)
        lens.setFilmOffset(0, 0)
        lens.setNearFar(-1000, 1000)
        quadcamnode.setLens(lens)
        quadcam = quad.attachNewNode(quadcamnode)
        
        buffer.getDisplayRegion(0).setCamera(quadcam)
        buffer.getDisplayRegion(0).setActive(1)

        self.buffers.append(buffer)
        self.sizes.append((mul, div, align))
        
        return quad
Пример #8
0
  def make_layer(self, i, a, b):
    # get data
    data = self.subdata[a][b]

    # set color + alpha of vertex texture
    def ap(n):
      alpha = 0
      if i == n:
        alpha = 1.0
      return alpha
    def tp(n):
      list = [0, 0, 0, 0]
      if i == n:
        list = [1, 1, 1, 0.75]
      return list

    # set vertex data
    vdata = GeomVertexData('plane', GeomVertexFormat.getV3n3c4t2(), Geom.UHStatic)
    vertex = GeomVertexWriter(vdata, 'vertex')
    normal = GeomVertexWriter(vdata, 'normal')
    color = GeomVertexWriter(vdata, 'color')
    uv = GeomVertexWriter(vdata, 'texcoord')

    # set vertices
    number = 0
    for x in range(0, len(data) - 1):
      for y in range(0, len(data[x]) - 1):
        # get vertex data
        v1 = Vec3(x, y, data[x][y]['h'])
        c1 = data[x][y]['c']
        t1 = data[x][y]['texnum']
        v2 = Vec3(x+1, y, data[x+1][y]['h'])
        c2 = data[x+1][y]['c']
        t2 = data[x+1][y]['texnum']
        v3 = Vec3(x+1, y+1, data[x+1][y+1]['h'])
        c3 = data[x+1][y+1]['c']
        t3 = data[x+1][y+1]['texnum']
        v4 = Vec3(x, y+1, data[x][y+1]['h'])
        c4 = data[x][y+1]['c']
        t4 = data[x][y+1]['texnum']
        n=(0, 0, 1) # normal

        # assign vertex colors + alpha
        a1, a2, a3, a4 = ap(t1), ap(t2), ap(t3), ap(t4)
        t1, t2, t3, t4 = tp(t1), tp(t2), tp(t3), tp(t4)

        if v1[2]==0:
          t1 = [data[x][y]['c'][0], data[x][y]['c'][1], data[x][y]['c'][2],
                a1]
        if v2[2]==0:
          t2 = [data[x+1][y]['c'][0], data[x+1][y]['c'][1],
                data[x+1][y]['c'][2], a2]
        if v3[2]==0:
          t3 = [data[x+1][y+1]['c'][0], data[x+1][y+1]['c'][1],
                data[x+1][y+1]['c'][2], a3]
        if v4[2]==0:
          t4 = [data[x][y+1]['c'][0], data[x][y+1]['c'][1],
                data[x][y+1]['c'][2], a4]

        if a1 == 0 and a2 == 0 and a3 == 0 and a4 == 0:
          continue

        # add vertices
        vertex.addData3f(v1)
        normal.addData3f(*n)
        color.addData4f(*t1)
        uv.addData2f(0,0)

        vertex.addData3f(v2)
        normal.addData3f(*n)
        color.addData4f(*t2)
        uv.addData2f(1,0)

        vertex.addData3f(v3)
        normal.addData3f(*n)
        color.addData4f(*t3)
        uv.addData2f(1,1)

        vertex.addData3f(v1)
        normal.addData3f(*n)
        color.addData4f(*t1)
        uv.addData2f(0,0)

        vertex.addData3f(v3)
        normal.addData3f(*n)
        color.addData4f(*t3)
        uv.addData2f(1,1)

        vertex.addData3f(v4)
        normal.addData3f(*n)
        color.addData4f(*t4)
        uv.addData2f(0,1)

        number = number + 2

    # add triangles
    prim = GeomTriangles(Geom.UHStatic)
    for n in range(number):
      prim.addVertices((n * 3) + 2, (n * 3) + 0, (n * 3) + 1)
    prim.closePrimitive()

    # make geom
    geom = Geom(vdata)
    geom.addPrimitive(prim)

    # make geom node
    node = GeomNode("layer" + str(i) + "_" + str(a) + "_" + str(b))
    node.addGeom(geom)

    # make mesh nodePath
    mesh = NodePath(node)

    # load and assign texture
    txfile = self.tiles[i]['tex']
    tx = base.loader.loadTexture(txfile)
    tx.setMinfilter(Texture.FTLinearMipmapLinear)
    mesh.setDepthTest(DepthTestAttrib.MLessEqual)
    mesh.setDepthWrite(False)
    mesh.setTransparency(True)
    mesh.setTexture(tx)

    # set render order
    mesh.setBin("", 1)

    # locate mesh
    mesh.setPos(self.divsep * (a * int(len(self.data[a]) / self.div)),
                self.divsep * (b * int(len(self.data[b]) / self.div)), 0.001)

    # reparent mesh
    mesh.reparentTo(self.root)

    # return mesh
    return mesh
Пример #9
0
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
Пример #10
0
    def renderSceneInto(self, depthtex=None, colortex=None, auxtex=None, auxbits=0, textures=None):

        """ Causes the scene to be rendered into the supplied textures
        instead of into the original window.  Puts a fullscreen quad
        into the original window to show the render-to-texture results.
        Returns the quad.  Normally, the caller would then apply a
        shader to the quad.

        To elaborate on how this all works:

        * An offscreen buffer is created.  It is set up to mimic
          the original display region - it is the same size,
          uses the same clear colors, and contains a DisplayRegion
          that uses the original camera.

        * A fullscreen quad and an orthographic camera to render
          that quad are both created.  The original camera is
          removed from the original window, and in its place, the
          orthographic quad-camera is installed.

        * The fullscreen quad is textured with the data from the
          offscreen buffer.  A shader is applied that tints the
          results pink.

        * Automatic shader generation NOT enabled.
          If you have a filter that depends on a render target from
          the auto-shader, you either need to set an auto-shader
          attrib on the main camera or scene, or, you need to provide
          these outputs in your own shader.

        * All clears are disabled on the original display region.
          If the display region fills the whole window, then clears
          are disabled on the original window as well.  It is
          assumed that rendering the full-screen quad eliminates
          the need to do clears.

        Hence, the original window which used to contain the actual
        scene, now contains a pink-tinted quad with a texture of the
        scene.  It is assumed that the user will replace the shader
        on the quad with a more interesting filter. """

        if (textures):
            colortex = textures.get("color", None)
            depthtex = textures.get("depth", None)
            auxtex = textures.get("aux", None)

        if (colortex == None):
            colortex = Texture("filter-base-color")
            colortex.setWrapU(Texture.WMClamp)
            colortex.setWrapV(Texture.WMClamp)

        texgroup = (depthtex, colortex, auxtex, None)

        # Choose the size of the offscreen buffer.

        (winx, winy) = self.getScaledSize(1,1,1)
        buffer = self.createBuffer("filter-base", winx, winy, texgroup)

        if (buffer == None):
            return None

        cm = CardMaker("filter-base-quad")
        cm.setFrameFullscreenQuad()
        quad = NodePath(cm.generate())
        quad.setDepthTest(0)
        quad.setDepthWrite(0)
        quad.setTexture(colortex)
        quad.setColor(Vec4(1,0.5,0.5,1))

        cs = NodePath("dummy")
        cs.setState(self.camstate)
        # Do we really need to turn on the Shader Generator?
        #cs.setShaderAuto()
        if (auxbits):
            cs.setAttrib(AuxBitplaneAttrib.make(auxbits))
        self.camera.node().setInitialState(cs.getState())

        quadcamnode = Camera("filter-quad-cam")
        lens = OrthographicLens()
        lens.setFilmSize(2, 2)
        lens.setFilmOffset(0, 0)
        lens.setNearFar(-1000, 1000)
        quadcamnode.setLens(lens)
        quadcam = quad.attachNewNode(quadcamnode)
        
        self.region.setCamera(quadcam)

        dr = buffer.getDisplayRegion(0)
        self.setStackedClears(dr, self.rclears, self.wclears)
        if (auxtex):
            dr.setClearActive(GraphicsOutput.RTPAuxRgba0, 1)
            dr.setClearValue(GraphicsOutput.RTPAuxRgba0, Vec4(0.5,0.5,1.0,0.0))
        self.region.disableClears()
        if (self.isFullscreen()):
            self.win.disableClears()
        dr.setCamera(self.camera)
        dr.setActive(1)

        self.buffers.append(buffer)
        self.sizes.append((1, 1, 1))

        return quad
class FishLure(NodePath):
    def __init__(self, gameObject, type):
        NodePath.__init__(self, "FishingLure_%s" % type)
        self.gameObject = gameObject
        self.type = type
        self.initLureModel()
        if FishingGlobals.wantDebugCollisionVisuals:
            self.initCollision()

        self.initLureHelpText()
        self.setLightOff()

    def initLureModel(self):
        self.lureModel = NodePath("lure")
        self.currentLureType = "regular"
        self.lureAttractRadius = FishingGlobals.lureTypeToAttractRadius[self.currentLureType]
        self.lureModel = loader.loadModel(FishingGlobals.lureTypeToModel[self.currentLureType])
        self.lureModel.setScale(2.0)
        self.lureModel.reparentTo(self)
        self.lureModel.setDepthWrite(False)
        self.lureModel.setDepthTest(True)
        self.lureModel.setBin("ground", 25)
        self.mainGui = loader.loadModel("models/gui/gui_main")

    def initCollision(self):
        self.lureCollisionVisual = loader.loadModel("models/ammunition/cannonball")
        self.lureCollisionVisual.setTransparency(1)
        self.lureCollisionVisual.setColor(0.0, 0.0, 1.0, 0.29999999999999999)
        self.lureCollisionVisual.setScale(self.lureAttractRadius)
        self.lureCollisionVisual.reparentTo(self)
        self.lureCollisionVisual.hide()

    def initLureHelpText(self):
        self.helpTextNode = TextNode("fishBitingIcon")
        self.helpTextNodePath = NodePath(self.helpTextNode)
        self.helpTextNodePath.setPos(0.0, 0.0, 0.69999999999999996)
        self.helpTextNode.setText(" ")
        self.helpTextNode.setAlign(TextNode.ACenter)
        self.helpTextNode.setFont(PiratesGlobals.getPirateFont())
        self.helpTextNode.setTextColor(1.0, 1.0, 1.0, 1.0)
        self.helpTextNodePath.reparentTo(self)
        self.helpTextNodePath.setBillboardPointEye()
        self.helpTextNodePath.setBin("fishingGame", 10)
        self.helpTextNodePath.hide()

    def enableLureGlow(self, glowType):
        self.lureGlow = LureGlow.getEffect()
        if self.lureGlow:
            if self.gameObject.fishManager.activeFish is not None:
                self.lureGlow.reparentTo(self.gameObject.fishManager.activeFish.mouthJoint)
            else:
                self.lureGlow.reparentTo(self)
            self.lureGlow.effectColor = _glowColors[glowType]
            self.lureGlow.setShaderOff()
            self.lureGlow.setBin("fishingGame", 5)
            self.lureGlow.play()

    def showHelpText(self, textToShow):
        taskMgr.remove(self.gameObject.distributedFishingSpot.uniqueName("ClearLureText"))
        if textToShow is None:
            self.helpTextNode.setText(" ")
            self.helpTextNodePath.hide()
        elif self.gameObject.fishManager.activeFish is not None:
            self.helpTextNodePath.setScale(
                FishingGlobals.fishSizeToHelpTextScale[self.gameObject.fishManager.activeFish.myData["size"]]
            )
        else:
            self.helpTextNodePath.setScale(1.0)
        self.helpTextNode.setText(textToShow)
        self.helpTextNodePath.show()
        taskMgr.doMethodLater(
            FishingGlobals.lureHelpTextDuration,
            self.showHelpText,
            name=self.gameObject.distributedFishingSpot.uniqueName("ClearLureText"),
            extraArgs=[None],
        )

    def setLureType(self, type):
        self.currentLureType = type
        if type == None:
            self.lureModel.hide()
            self.gameObject.gui.setTackleBoxPulse(True)
        elif type == "regular":
            self.gameObject.gui.setTackleBoxPulse(False)
            self.currentLureType = type
            self.lureModel.removeNode()
            self.lureAttractRadius = FishingGlobals.lureTypeToAttractRadius[type]
            self.lureModel = loader.loadModel(FishingGlobals.lureTypeToModel[type])
            self.lureModel.setScale(2.0)
            self.lureModel.reparentTo(self)
            self.lureModel.setDepthWrite(False)
            self.lureModel.setDepthTest(True)
            self.lureModel.setBin("ground", 25)
        elif type == "legendary":
            self.gameObject.gui.setTackleBoxPulse(False)
            self.currentLureType = type
            self.lureModel.removeNode()
            self.lureAttractRadius = FishingGlobals.lureTypeToAttractRadius[type]
            self.lureModel = loader.loadModel(FishingGlobals.lureTypeToModel[type])
            self.lureModel.setScale(2.0)
            self.lureModel.reparentTo(self)
            self.lureModel.setDepthWrite(False)
            self.lureModel.setDepthTest(True)
            self.lureModel.setBin("ground", 25)

    def showCollisionVisuals(self):
        if FishingGlobals.wantDebugCollisionVisuals:
            self.lureCollisionVisual.show()

    def hideCollisionVisuals(self):
        if FishingGlobals.wantDebugCollisionVisuals:
            self.lureCollisionVisual.hide()

    def requestPitch(self, fish):
        offset = fish.getPos() - self.getPos()
        if fish.getX() < self.getX():
            return math.degrees(math.atan2(offset.getZ(), -offset.getX()))
        else:
            return math.degrees(math.atan2(-offset.getZ(), offset.getX()))

    def resetLureModel(self):
        self.lureModel.reparentTo(self)
        self.lureModel.show()
        self.lureModel.setPosHpr(0, 0, 0, 0, 0, 0.0)
        if self.currentLureType == None:
            self.lureModel.hide()
            self.gameObject.gui.setTackleBoxPulse(True)
        else:
            self.gameObject.gui.setTackleBoxPulse(False)

    def destroy(self):
        self.lureModel.removeNode()
        self.removeNode()
Пример #12
0
    def renderSceneInto(self, depthtex=None, colortex=None, auxtex=None, auxbits=0, textures=None):

        """ Causes the scene to be rendered into the supplied textures
        instead of into the original window.  Puts a fullscreen quad
        into the original window to show the render-to-texture results.
        Returns the quad.  Normally, the caller would then apply a
        shader to the quad.

        To elaborate on how this all works:

        * An offscreen buffer is created.  It is set up to mimic
          the original display region - it is the same size,
          uses the same clear colors, and contains a DisplayRegion
          that uses the original camera.

        * A fullscreen quad and an orthographic camera to render
          that quad are both created.  The original camera is
          removed from the original window, and in its place, the
          orthographic quad-camera is installed.

        * The fullscreen quad is textured with the data from the
          offscreen buffer.  A shader is applied that tints the
          results pink.

        * Automatic shader generation NOT enabled.
          If you have a filter that depends on a render target from
          the auto-shader, you either need to set an auto-shader
          attrib on the main camera or scene, or, you need to provide
          these outputs in your own shader.

        * All clears are disabled on the original display region.
          If the display region fills the whole window, then clears
          are disabled on the original window as well.  It is
          assumed that rendering the full-screen quad eliminates
          the need to do clears.

        Hence, the original window which used to contain the actual
        scene, now contains a pink-tinted quad with a texture of the
        scene.  It is assumed that the user will replace the shader
        on the quad with a more interesting filter. """

        if (textures):
            colortex = textures.get("color", None)
            depthtex = textures.get("depth", None)
            auxtex = textures.get("aux", None)
            auxtex0 = textures.get("aux0", auxtex)
            auxtex1 = textures.get("aux1", None)
        else:
            auxtex0 = auxtex
            auxtex1 = None

        if (colortex == None):
            colortex = Texture("filter-base-color")
            colortex.setWrapU(Texture.WMClamp)
            colortex.setWrapV(Texture.WMClamp)

        texgroup = (depthtex, colortex, auxtex0, auxtex1)

        # Choose the size of the offscreen buffer.

        (winx, winy) = self.getScaledSize(1,1,1)
        buffer = self.createBuffer("filter-base", winx, winy, texgroup)

        if (buffer == None):
            return None

        cm = CardMaker("filter-base-quad")
        cm.setFrameFullscreenQuad()
        quad = NodePath(cm.generate())
        quad.setDepthTest(0)
        quad.setDepthWrite(0)
        quad.setTexture(colortex)
        quad.setColor(Vec4(1,0.5,0.5,1))

        cs = NodePath("dummy")
        cs.setState(self.camstate)
        # Do we really need to turn on the Shader Generator?
        #cs.setShaderAuto()
        if (auxbits):
            cs.setAttrib(AuxBitplaneAttrib.make(auxbits))
        self.camera.node().setInitialState(cs.getState())

        quadcamnode = Camera("filter-quad-cam")
        lens = OrthographicLens()
        lens.setFilmSize(2, 2)
        lens.setFilmOffset(0, 0)
        lens.setNearFar(-1000, 1000)
        quadcamnode.setLens(lens)
        quadcam = quad.attachNewNode(quadcamnode)
        
        self.region.setCamera(quadcam)

        self.setStackedClears(buffer, self.rclears, self.wclears)
        if (auxtex0):
            buffer.setClearActive(GraphicsOutput.RTPAuxRgba0, 1)
            buffer.setClearValue(GraphicsOutput.RTPAuxRgba0, Vec4(0.5, 0.5, 1.0, 0.0))
        if (auxtex1):
            buffer.setClearActive(GraphicsOutput.RTPAuxRgba1, 1)
        self.region.disableClears()
        if (self.isFullscreen()):
            self.win.disableClears()

        dr = buffer.makeDisplayRegion()
        dr.disableClears()
        dr.setCamera(self.camera)
        dr.setActive(1)

        self.buffers.append(buffer)
        self.sizes.append((1, 1, 1))

        return quad
Пример #13
0
class FishLure(NodePath):
    def __init__(self, gameObject, type):
        NodePath.__init__(self, 'FishingLure_%s' % type)
        self.gameObject = gameObject
        self.type = type
        self.initLureModel()
        if FishingGlobals.wantDebugCollisionVisuals:
            self.initCollision()

        self.initLureHelpText()
        self.setLightOff()

    def initLureModel(self):
        self.lureModel = NodePath('lure')
        self.currentLureType = 'regular'
        self.lureAttractRadius = FishingGlobals.lureTypeToAttractRadius[
            self.currentLureType]
        self.lureModel = loader.loadModel(
            FishingGlobals.lureTypeToModel[self.currentLureType])
        self.lureModel.setScale(2.0)
        self.lureModel.reparentTo(self)
        self.lureModel.setDepthWrite(False)
        self.lureModel.setDepthTest(True)
        self.lureModel.setBin('ground', 25)
        self.mainGui = loader.loadModel('models/gui/gui_main')

    def initCollision(self):
        self.lureCollisionVisual = loader.loadModel(
            'models/ammunition/cannonball')
        self.lureCollisionVisual.setTransparency(1)
        self.lureCollisionVisual.setColor(0.0, 0.0, 1.0, 0.29999999999999999)
        self.lureCollisionVisual.setScale(self.lureAttractRadius)
        self.lureCollisionVisual.reparentTo(self)
        self.lureCollisionVisual.hide()

    def initLureHelpText(self):
        self.helpTextNode = TextNode('fishBitingIcon')
        self.helpTextNodePath = NodePath(self.helpTextNode)
        self.helpTextNodePath.setPos(0.0, 0.0, 0.69999999999999996)
        self.helpTextNode.setText(' ')
        self.helpTextNode.setAlign(TextNode.ACenter)
        self.helpTextNode.setFont(PiratesGlobals.getPirateFont())
        self.helpTextNode.setTextColor(1.0, 1.0, 1.0, 1.0)
        self.helpTextNodePath.reparentTo(self)
        self.helpTextNodePath.setBillboardPointEye()
        self.helpTextNodePath.setBin('fishingGame', 10)
        self.helpTextNodePath.hide()

    def enableLureGlow(self, glowType):
        self.lureGlow = LureGlow.getEffect()
        if self.lureGlow:
            if self.gameObject.fishManager.activeFish is not None:
                self.lureGlow.reparentTo(
                    self.gameObject.fishManager.activeFish.mouthJoint)
            else:
                self.lureGlow.reparentTo(self)
            self.lureGlow.effectColor = _glowColors[glowType]
            self.lureGlow.setShaderOff()
            self.lureGlow.setBin('fishingGame', 5)
            self.lureGlow.play()

    def showHelpText(self, textToShow):
        taskMgr.remove(
            self.gameObject.distributedFishingSpot.uniqueName('ClearLureText'))
        if textToShow is None:
            self.helpTextNode.setText(' ')
            self.helpTextNodePath.hide()
        elif self.gameObject.fishManager.activeFish is not None:
            self.helpTextNodePath.setScale(
                FishingGlobals.fishSizeToHelpTextScale[
                    self.gameObject.fishManager.activeFish.myData['size']])
        else:
            self.helpTextNodePath.setScale(1.0)
        self.helpTextNode.setText(textToShow)
        self.helpTextNodePath.show()
        taskMgr.doMethodLater(
            FishingGlobals.lureHelpTextDuration,
            self.showHelpText,
            name=self.gameObject.distributedFishingSpot.uniqueName(
                'ClearLureText'),
            extraArgs=[None])

    def setLureType(self, type):
        self.currentLureType = type
        if type == None:
            self.lureModel.hide()
            self.gameObject.gui.setTackleBoxPulse(True)
        elif type == 'regular':
            self.gameObject.gui.setTackleBoxPulse(False)
            self.currentLureType = type
            self.lureModel.removeNode()
            self.lureAttractRadius = FishingGlobals.lureTypeToAttractRadius[
                type]
            self.lureModel = loader.loadModel(
                FishingGlobals.lureTypeToModel[type])
            self.lureModel.setScale(2.0)
            self.lureModel.reparentTo(self)
            self.lureModel.setDepthWrite(False)
            self.lureModel.setDepthTest(True)
            self.lureModel.setBin('ground', 25)
        elif type == 'legendary':
            self.gameObject.gui.setTackleBoxPulse(False)
            self.currentLureType = type
            self.lureModel.removeNode()
            self.lureAttractRadius = FishingGlobals.lureTypeToAttractRadius[
                type]
            self.lureModel = loader.loadModel(
                FishingGlobals.lureTypeToModel[type])
            self.lureModel.setScale(2.0)
            self.lureModel.reparentTo(self)
            self.lureModel.setDepthWrite(False)
            self.lureModel.setDepthTest(True)
            self.lureModel.setBin('ground', 25)

    def showCollisionVisuals(self):
        if FishingGlobals.wantDebugCollisionVisuals:
            self.lureCollisionVisual.show()

    def hideCollisionVisuals(self):
        if FishingGlobals.wantDebugCollisionVisuals:
            self.lureCollisionVisual.hide()

    def requestPitch(self, fish):
        offset = fish.getPos() - self.getPos()
        if fish.getX() < self.getX():
            return math.degrees(math.atan2(offset.getZ(), -offset.getX()))
        else:
            return math.degrees(math.atan2(-offset.getZ(), offset.getX()))

    def resetLureModel(self):
        self.lureModel.reparentTo(self)
        self.lureModel.show()
        self.lureModel.setPosHpr(0, 0, 0, 0, 0, 0.0)
        if self.currentLureType == None:
            self.lureModel.hide()
            self.gameObject.gui.setTackleBoxPulse(True)
        else:
            self.gameObject.gui.setTackleBoxPulse(False)

    def destroy(self):
        self.lureModel.removeNode()
        self.removeNode()