コード例 #1
0
	def initAgents(self):
		"""
		Setup agents.

		For this techdemo we have a very simple 'active things on the map' model,
		which is called agents. All rio maps will have a separate layer for them.

		Note that we keep a mapping from map instances (C++ model of stuff on the map)
		to the python agents for later reference.
		"""
		self.agentlayer = self.map.getLayer('TechdemoMapGroundObjectLayer')
		self.hero = Hero(TDS, self.model, 'PC', self.agentlayer)
		self.instance_to_agent[self.hero.agent.getFifeId()] = self.hero
		self.hero.start()

		self.girl = Girl(TDS, self.model, 'NPC:girl', self.agentlayer)
		self.instance_to_agent[self.girl.agent.getFifeId()] = self.girl
		self.girl.start()

		# Fog of War stuff
		#self.hero.agent.setVisitor(True)
		#self.hero.agent.setVisitorRadius(2)
		#self.girl.agent.setVisitor(True)
		#self.girl.agent.setVisitorRadius(1)

		self.beekeepers = create_anonymous_agents(TDS, self.model, 'beekeeper', self.agentlayer, Beekeeper)
		for beekeeper in self.beekeepers:
			self.instance_to_agent[beekeeper.agent.getFifeId()] = beekeeper
			beekeeper.start()

		# Clouds are currently defunct.
		cloudlayer = self.map.getLayer('TechdemoMapTileLayer')
		self.clouds = create_anonymous_agents(TDS, self.model, 'Cloud', cloudlayer, Cloud)
		for cloud in self.clouds:
			cloud.start(0.1, 0.05)
コード例 #2
0
ファイル: world.py プロジェクト: karottenreibe/FIFE
	def initAgents(self):
		"""
		Setup agents.

		For this techdemo we have a very simple 'active things on the map' model,
		which is called agents. All rio maps will have a separate layer for them.

		Note that we keep a mapping from map instances (C++ model of stuff on the map)
		to the python agents for later reference.
		"""
		self.agentlayer = self.map.getLayer('TechdemoMapGroundObjectLayer')
		self.hero = Hero(TDS, self.model, 'PC', self.agentlayer)
		self.instance_to_agent[self.hero.agent.getFifeId()] = self.hero
		self.hero.start()

		self.girl = Girl(TDS, self.model, 'NPC:girl', self.agentlayer)
		self.instance_to_agent[self.girl.agent.getFifeId()] = self.girl
		self.girl.start()

		self.beekeepers = create_anonymous_agents(TDS, self.model, 'beekeeper', self.agentlayer, Beekeeper)
		for beekeeper in self.beekeepers:
			self.instance_to_agent[beekeeper.agent.getFifeId()] = beekeeper
			beekeeper.start()

		# Clouds are currently defunct.
		cloudlayer = self.map.getLayer('TechdemoMapTileLayer')
		self.clouds = create_anonymous_agents(TDS, self.model, 'Cloud', cloudlayer, Cloud)
		for cloud in self.clouds:
			cloud.start(0.1, 0.05)
コード例 #3
0
ファイル: world.py プロジェクト: mvbarracuda/parpg
	def load(self, filename):
		self.filename = filename
		self.reset()
		self.map = loadMapFile(filename, self.engine)
		self.maplistener = MapListener(self.map)

		self.agentlayer = self.map.getLayer('TechdemoMapGroundObjectLayer')
		self.hero = Hero(self.model, 'PC', self.agentlayer)
		self.instance_to_agent[self.hero.agent.getFifeId()] = self.hero
		self.hero.start()

		self.girl = Girl(self.model, 'NPC:girl', self.agentlayer)
		self.instance_to_agent[self.girl.agent.getFifeId()] = self.girl
		self.girl.start()

		self.beekeepers = create_anonymous_agents(self.model, 'beekeeper', self.agentlayer, Beekeeper)
		for beekeeper in self.beekeepers:
			self.instance_to_agent[beekeeper.agent.getFifeId()] = beekeeper
			beekeeper.start()

		cloudlayer = self.map.getLayer('TechdemoMapTileLayer')
		self.clouds = create_anonymous_agents(self.model, 'Cloud', cloudlayer, Cloud)
		for cloud in self.clouds:
			cloud.start(0.1, 0.05)

		for cam in self.view.getCameras():
			self.cameras[cam.getId()] = cam
		self.cameras['main'].attach(self.hero.agent)

		self.view.resetRenderers()
		renderer = fife.FloatingTextRenderer.getInstance(self.cameras['main'])
		textfont = self.engine.getGuiManager().createFont('fonts/rpgfont.png', 0, str(TDS.readSetting("FontGlyphs", strip=False)));
		renderer.changeDefaultFont(textfont)

		renderer = fife.FloatingTextRenderer.getInstance(self.cameras['small'])
		renderer.changeDefaultFont(None)

		renderer = self.cameras['main'].getRenderer('CoordinateRenderer')
		renderer.clearActiveLayers()
		renderer.addActiveLayer(self.map.getLayer(str(TDS.readSetting("CoordinateLayerName"))))

		renderer = self.cameras['main'].getRenderer('QuadTreeRenderer')
		renderer.setEnabled(True)
		renderer.clearActiveLayers()
		if str(TDS.readSetting("QuadTreeLayerName")):
			renderer.addActiveLayer(self.map.getLayer(str(TDS.readSetting("QuadTreeLayerName"))))

		self.cameras['small'].getLocationRef().setExactLayerCoordinates( fife.ExactModelCoordinate( 40.0, 40.0, 0.0 ))
		self.initial_cam2_x = self.cameras['small'].getLocation().getExactLayerCoordinates().x
		self.cur_cam2_x = self.initial_cam2_x
		self.cam2_scrolling_right = True
		self.cameras['small'].setEnabled(False)

		self.target_rotation = self.cameras['main'].getRotation()
コード例 #4
0
ファイル: world.py プロジェクト: fede1024/py-fifengine
    def initAgents(self):
        """
        Setup agents.

        For this techdemo we have a very simple 'active things on the map' model,
        which is called agents. All rio maps will have a separate layer for them.

        Note that we keep a mapping from map instances (C++ model of stuff on the map)
        to the python agents for later reference.
        """
        self.agentlayer = self.map.getLayer('TechdemoMapGroundObjectLayer')
        self.boy = Boy(TDS, self.model, 'PC', self.agentlayer, self.soundmanager, world = self)
        self.instance_to_agent[self.boy.agent.getFifeId()] = self.boy
        self.mainAgent = self.boy
        self.boy.start()

        self.girl = Girl(TDS, self.model, 'NPC:girl', self.agentlayer, self.soundmanager, world = self, looseCallback = self.loose, updateLifeCallback = self.gui.girlLifeUpdate)
        self.instance_to_agent[self.girl.agent.getFifeId()] = self.girl
        self.girl.start()

        self.priest = Priest(TDS, self.model, 'priest', self.agentlayer, self.soundmanager, world = self)
        self.instance_to_agent[self.priest.agent.getFifeId()] = self.priest
        self.priest.start()

        self.chemist = Chemist(TDS, self.model, 'chemist', self.agentlayer, self.soundmanager, world = self, winCallback=self.win)
        self.instance_to_agent[self.chemist.agent.getFifeId()] = self.chemist
        self.chemist.start()

        self.bees = []
        for i in xrange(num_bees):
            bee = Bee(TDS, self.model, 'bee' + str(i), self.agentlayer, self.soundmanager, girl = self.girl)
            self.instance_to_agent[bee.agent.getFifeId()] = bee
            bee.start()
            self.bees.append(bee)

        for i in xrange(12):
            dynamite = Dynamite(TDS, self.model, 'dyn_' + str(i), self.agentlayer, self.soundmanager, bees=self.bees, girl=self.girl)
            self.instance_to_agent[dynamite.agent.getFifeId()] = dynamite
            dynamite.start()

        self.beekeepers = create_anonymous_agents(TDS, self.model, 'beekeeper', self.agentlayer, Beekeeper, self.soundmanager)
        for beekeeper in self.beekeepers:
            self.instance_to_agent[beekeeper.agent.getFifeId()] = beekeeper
            beekeeper.start()
            
        moveObject(self.agentlayer.getInstance('flask0'), x=3.5, y=9.5)
        moveObject(self.agentlayer.getInstance('coins0'), x=-18, y=-15)
        moveObject(self.agentlayer.getInstance('coins1'), x=-22.5, y=-14.5)
        moveObject(self.agentlayer.getInstance('coins2'), x=-18, y=-14.5)
コード例 #5
0
    def initAgents(self):
        """
        Setup agents.

        For this techdemo we have a very simple 'active things on the map' model,
        which is called agents. All rio maps will have a separate layer for them.

        Note that we keep a mapping from map instances (C++ model of stuff on the map)
        to the python agents for later reference.
        """
        self.agentlayer = self.map.getLayer('TechdemoMapGroundObjectLayer')
        self.hero = Hero(TDS, self.model, 'PC', self.agentlayer)
        self.instance_to_agent[self.hero.agent.getFifeId()] = self.hero
        self.hero.start()

        self.girl = Girl(TDS, self.model, 'NPC:girl', self.agentlayer)
        self.instance_to_agent[self.girl.agent.getFifeId()] = self.girl
        self.girl.start()
        
        self.bees = create_anonymous_agents(TDS, self.model, 'bee', self.agentlayer,Bee)
        for bee in self.bees:
            self.instance_to_agent[bee.agent.getFifeId()] = bee
            bee.start()
   
        self.beekeepers = create_anonymous_agents(TDS, self.model, 'beekeeper', self.agentlayer, Beekeeper)
        for beekeeper in self.beekeepers:
            self.instance_to_agent[beekeeper.agent.getFifeId()] = beekeeper
            beekeeper.start()
        
        self.tourist_male2 = create_anonymous_agents(TDS, self.model, 'tourist_male2',self.agentlayer, Tourist_male2)
        for tourist_male2 in self.tourist_male2:
            self.instance_to_agent[tourist_male2.agent.getFifeId()] = tourist_male2
            tourist_male2.start()

        self.hippie_priest = Hippie_priest(TDS, self.model, 'hippie_priest', self.agentlayer)
        self.instance_to_agent[self.hippie_priest.agent.getFifeId()] = self.hippie_priest
        self.hippie_priest.start()
コード例 #6
0
ファイル: world.py プロジェクト: fede1024/py-fifengine
class World(EventListenerBase):
    """
    The world!

    This class handles:
      setup of map view (cameras ...)
      loading the map
      GUI for right clicks
      handles mouse/key events which aren't handled by the GUI.
       ( by inheriting from EventlistenerBase )

    That's obviously too much, and should get factored out.
    """
    def __init__(self, engine):
        super(World, self).__init__(engine, regMouse=True, regKeys=True)
        self.engine = engine
        self.eventmanager = engine.getEventManager()
        self.model = engine.getModel()
        self.filename = ''
        self.pump_ctr = 0 # for testing purposis
        self.ctrldown = False
        self.instancemenu = None
        self.instance_to_agent = {}
        self.dynamic_widgets = {}
        self.gui = None # Overwritten during GUI initialization

        self.light_intensity = 1
        self.light_sources = 0
        self.lightmodel = 1  # DK why

        self.soundmanager = SoundManager(self.engine)
        self.music = None

    def show_instancemenu(self, clickpoint, location, instance):
        """
        Build and show a popupmenu for an instance that the player
        clicked on. The available actions are dynamically added to
        the menu (and mapped to the onXYZ functions).
        """
        if instance and instance.getFifeId() == self.mainAgent.agent.getFifeId(): # click on yourself
            return

        # Create the popup.
        self.build_instancemenu()
        self.instancemenu.clickpoint = clickpoint
        self.instancemenu.location = location
        self.instancemenu.instance = instance

        # Add the buttons according to circumstances.
        if instance:
            target_distance = self.mainAgent.agent.getLocation().getLayerDistanceTo(instance.getLocation())
        else:
            target_distance = 0
        
        if instance and self.instance_to_agent.has_key(instance.getFifeId()):
            target_agent = self.instance_to_agent[instance.getFifeId()]
        else:
            target_agent = None
            
        actionList = self.mainAgent.getActionsList(instance, target_agent, target_distance)
        
        for action in actionList:
            if self.dynamic_widgets.has_key(action): 
                self.instancemenu.addChild(self.dynamic_widgets[action])
            else:
                print "ERROR: no defined action %s for instance menu."%action
        
#         self.instancemenu.addChild(self.dynamic_widgets['inspect'])
#         if target_distance > 3.0:
#             self.instancemenu.addChild(self.dynamic_widgets['move'])
#         else:
#             if self.instance_to_agent.has_key(instance.getFifeId()):
#                 self.instancemenu.addChild(self.dynamic_widgets['talk'])
#                 if self.mainAgent == self.boy:
#                     self.instancemenu.addChild(self.dynamic_widgets['kick'])
        # And show it :)
        self.instancemenu.position = (clickpoint.x, clickpoint.y)
        self.instancemenu.show()

    def build_instancemenu(self):
        """
        Just loads the menu from an XML file
        and hooks the events up.
        The buttons are removed and later re-added if appropiate.
        """
        self.hide_instancemenu()
        dynamicbuttons = ('move', 'talk', 'open', 'kick', 'inspect', 'pick', 'lay') 
        self.instancemenu = pychan.loadXML('gui/xml/instancemenu.xml')
        self.instancemenu.mapEvents({
            'move' : lambda: self.onAction('move'),
            'talk' : lambda: self.onAction('talk'),
            'kick' : lambda: self.onAction('kick'),
            'open' : lambda: self.onAction('open'),
            'pick' : lambda: self.onAction('pick'),
            'lay' : lambda: self.onAction('lay'),
            'inspect' : lambda: self.onAction('inspect'),
        })
        for btn in dynamicbuttons:
            self.dynamic_widgets[btn] = self.instancemenu.findChild(name=btn)
        self.instancemenu.removeAllChildren()

    def hide_instancemenu(self):
        if self.instancemenu:
            self.instancemenu.hide()

    def reset(self):
        """
        Clear the agent information and reset the moving secondary camera state.
        """
        if self.music:
            self.music.stop()
            
        self.map, self.agentlayer = None, None
        self.cameras = {}
        self.boy, self.girl, self.clouds, self.beekeepers = None, None, [], []
        self.cur_cam2_x, self.initial_cam2_x, self.cam2_scrolling_right = 0, 0, True
        self.target_rotation = 0
        self.instance_to_agent = {}

    def load(self, filename):
        """
        Load a xml map and setup agents and cameras.
        """
        
        self.filename = filename
        self.reset()
        loader = fife.MapLoader(self.engine.getModel(), 
                                self.engine.getVFS(), 
                                self.engine.getImageManager(), 
                                self.engine.getRenderBackend())
                                
        if loader.isLoadable(filename):
            self.map = loader.load(filename)

        self.initAgents()
        self.initCameras()

        #Set background color
        self.engine.getRenderBackend().setBackgroundColor(80,80,255)

        # play track as background music
        self.music = self.soundmanager.createSoundEmitter('music/hang.ogg')
        self.music.looping = True
        self.music.gain = 128

        if int(Setting(app_name="rio_de_hola").get("FIFE", "PlaySounds")):
            self.music.play()
            self.soundActive = True
        else:
            self.soundActive = False
            
    def loose(self):
        self.cameras['main'].setOverlayColor(0,0,0,180)
        self.gui.youLoose()
    
    def win(self):
        self.cameras['main'].setOverlayColor(0,0,255,180)
        self.gui.youWin()
    
    def showItems(self, items):
        self.gui.showItems(items)

    def hideItems(self, items):
        self.gui.hideItems(items)

    def restart(self):
        self.model.deleteMaps()
        self.load(self.filename)
        
    def initAgents(self):
        """
        Setup agents.

        For this techdemo we have a very simple 'active things on the map' model,
        which is called agents. All rio maps will have a separate layer for them.

        Note that we keep a mapping from map instances (C++ model of stuff on the map)
        to the python agents for later reference.
        """
        self.agentlayer = self.map.getLayer('TechdemoMapGroundObjectLayer')
        self.boy = Boy(TDS, self.model, 'PC', self.agentlayer, self.soundmanager, world = self)
        self.instance_to_agent[self.boy.agent.getFifeId()] = self.boy
        self.mainAgent = self.boy
        self.boy.start()

        self.girl = Girl(TDS, self.model, 'NPC:girl', self.agentlayer, self.soundmanager, world = self, looseCallback = self.loose, updateLifeCallback = self.gui.girlLifeUpdate)
        self.instance_to_agent[self.girl.agent.getFifeId()] = self.girl
        self.girl.start()

        self.priest = Priest(TDS, self.model, 'priest', self.agentlayer, self.soundmanager, world = self)
        self.instance_to_agent[self.priest.agent.getFifeId()] = self.priest
        self.priest.start()

        self.chemist = Chemist(TDS, self.model, 'chemist', self.agentlayer, self.soundmanager, world = self, winCallback=self.win)
        self.instance_to_agent[self.chemist.agent.getFifeId()] = self.chemist
        self.chemist.start()

        self.bees = []
        for i in xrange(num_bees):
            bee = Bee(TDS, self.model, 'bee' + str(i), self.agentlayer, self.soundmanager, girl = self.girl)
            self.instance_to_agent[bee.agent.getFifeId()] = bee
            bee.start()
            self.bees.append(bee)

        for i in xrange(12):
            dynamite = Dynamite(TDS, self.model, 'dyn_' + str(i), self.agentlayer, self.soundmanager, bees=self.bees, girl=self.girl)
            self.instance_to_agent[dynamite.agent.getFifeId()] = dynamite
            dynamite.start()

        self.beekeepers = create_anonymous_agents(TDS, self.model, 'beekeeper', self.agentlayer, Beekeeper, self.soundmanager)
        for beekeeper in self.beekeepers:
            self.instance_to_agent[beekeeper.agent.getFifeId()] = beekeeper
            beekeeper.start()
            
        moveObject(self.agentlayer.getInstance('flask0'), x=3.5, y=9.5)
        moveObject(self.agentlayer.getInstance('coins0'), x=-18, y=-15)
        moveObject(self.agentlayer.getInstance('coins1'), x=-22.5, y=-14.5)
        moveObject(self.agentlayer.getInstance('coins2'), x=-18, y=-14.5)
            
    def initCameras(self):
        """
        Before we can actually see something on screen we have to specify the render setup.
        This is done through Camera objects which offer a viewport on the map.

        For this techdemo two cameras are used. One follows the boy(!) via 'attach'
        the other one scrolls around a bit (see the pump function).
        """
        camera_prefix = self.filename.rpartition('.')[0] # Remove file extension
        camera_prefix = camera_prefix.rpartition('/')[2] # Remove path
        camera_prefix += '_'
        self.target_rotation  = 0
        self.cameras = {}
        
        for cam in self.map.getCameras():
            camera_id = cam.getId().replace(camera_prefix, '')
            self.cameras[camera_id] = cam
            cam.resetRenderers()
            
        self.cameras['main'].attach(self.mainAgent.agent)

        # Floating text renderers currntly only support one font.
        # ... so we set that up.
        # You'll se that for our demo we use a image font, so we have to specify the font glyphs
        # for that one.
        renderer = fife.FloatingTextRenderer.getInstance(self.cameras['main'])
        textfont = get_manager().createFont('fonts/rpgfont.png', 0, str(TDS.get("FIFE", "FontGlyphs")));
        renderer.setFont(textfont)
        renderer.activateAllLayers(self.map)
        renderer.setBackground(100, 255, 100, 165)
        renderer.setBorder(50, 255, 50)
        renderer.setEnabled(True)
        
        # Activate the grid renderer on all layers
        renderer = self.cameras['main'].getRenderer('GridRenderer')
        renderer.activateAllLayers(self.map)
        
        # The small camera shouldn't be cluttered by the 'humm di dums' of our boy.
        # So we disable the renderer simply by setting its font to None.
        renderer = fife.FloatingTextRenderer.getInstance(self.cameras['small'])
        renderer.setFont(None)

        # The following renderers are used for debugging.
        # Note that by default ( that is after calling View.resetRenderers or Camera.resetRenderers )
        # renderers will be handed all layers. That's handled here.
        renderer = fife.CoordinateRenderer.getInstance(self.cameras['main'])
        renderer.setFont(textfont)
        renderer.clearActiveLayers()
        renderer.addActiveLayer(self.map.getLayer(str(TDS.get("rio", "CoordinateLayerName"))))

        renderer = self.cameras['main'].getRenderer('QuadTreeRenderer')
        renderer.setEnabled(True)
        renderer.clearActiveLayers()
        if str(TDS.get("rio", "QuadTreeLayerName")):
            renderer.addActiveLayer(self.map.getLayer(str(TDS.get("rio", "QuadTreeLayerName"))))

        # Fog of War stuff
        renderer = fife.CellRenderer.getInstance(self.cameras['main'])
        renderer.setEnabled(True)
        renderer.clearActiveLayers()
        renderer.addActiveLayer(self.map.getLayer('TechdemoMapGroundObjectLayer'))
        concimg = self.engine.getImageManager().load("misc/black_cell.png")
        maskimg = self.engine.getImageManager().load("misc/mask_cell.png")
        renderer.setConcealImage(concimg)
        renderer.setMaskImage(maskimg)
        renderer.setFogOfWarLayer(self.map.getLayer('TechdemoMapGroundObjectLayer'))
        
        #disable FoW by default.  Users can turn it on with the 'f' key.
        renderer.setEnabledFogOfWar(False)

        # Set up the second camera
        # NOTE: We need to explicitly call setLocation, there's a bit of a messup in the Camera code.
        self.cameras['small'].setLocation(self.boy.agent.getLocation())
        self.cameras['small'].attach(self.girl.agent)
        self.cameras['small'].setOverlayColor(100,0,0,100)
        self.cameras['small'].setEnabled(False)

        self.target_rotation = self.cameras['main'].getRotation()


    def save(self, filename):
        saveMapFile(filename, self.engine, self.map)

    def getInstancesAt(self, clickpoint):
        """
        Query the main camera for instances on our active(agent) layer.
        """
        return self.cameras['main'].getMatchingInstances(clickpoint, self.agentlayer)

    def getLocationAt(self, clickpoint):
        """
        Query the main camera for the Map location (on the agent layer)
        that a screen point refers to.
        """
        target_mapcoord = self.cameras['main'].toMapCoordinates(clickpoint, False)
        target_mapcoord.z = 0
        location = fife.Location(self.agentlayer)
        location.setMapCoordinates(target_mapcoord)
        return location

    def keyPressed(self, evt):
        if self.girl.dead:
            return
        keyval = evt.getKey().getValue()
        keystr = evt.getKey().getAsString().lower()
        if keystr == 't':
            r = self.cameras['main'].getRenderer('GridRenderer')
            r.setEnabled(not r.isEnabled())
        elif keystr == 'c':
            r = self.cameras['main'].getRenderer('CoordinateRenderer')
            r.setEnabled(not r.isEnabled())
        elif keystr == 's':
            c = self.cameras['small']
            c.setEnabled(not c.isEnabled())
        elif keystr == 'r':
            self.model.deleteMaps()
            self.load(self.filename)
            self.gui.girlLifeUpdate(100)
            self.startTime = datetime.datetime.now()
        elif keystr == 'f':
            renderer = fife.CellRenderer.getInstance(self.cameras['main'])
            renderer.setEnabledFogOfWar(not renderer.isEnabledFogOfWar())
            self.cameras['main'].refresh()
        elif keystr == 'o':
            self.target_rotation = (self.target_rotation + 90) % 360
        elif keystr == '2':
            self.lightIntensity(0.1)
        elif keystr == '1':
            self.lightIntensity(-0.1)
        elif keystr == '5':
            self.lightSourceIntensity(25)
        elif keystr == '4':
            self.lightSourceIntensity(-25)
        elif keystr == '0' or keystr == fife.Key.NUM_0:
            if self.ctrldown:
                self.cameras['main'].setZoom(1.0)
        elif keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
            self.ctrldown = True
        else:
            self.mainAgent.keyPressed(keyval)

    def keyReleased(self, evt):
        if self.girl.dead:
            return
        keyval = evt.getKey().getValue()
        if keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
            self.ctrldown = False

    def mouseWheelMovedUp(self, evt):
        if self.girl.dead:
            return
        if self.ctrldown:
            self.cameras['main'].setZoom(self.cameras['main'].getZoom() * 1.05)

    def mouseWheelMovedDown(self, evt):
        if self.girl.dead:
            return
        if self.ctrldown:
            self.cameras['main'].setZoom(self.cameras['main'].getZoom() / 1.05)

    def changeRotation(self):
        """
        Smoothly change the main cameras rotation until
        the current target rotation is reached.
        """
        if "main" in self.cameras:
            currot = self.cameras['main'].getRotation()
            if self.target_rotation != currot:
                self.cameras['main'].setRotation((currot + 5) % 360)

    def mousePressed(self, evt):
        if evt.isConsumedByWidgets() or self.girl.dead:
            return

        clickpoint = fife.ScreenPoint(evt.getX(), evt.getY())
        if (evt.getButton() == fife.MouseEvent.LEFT):
            self.hide_instancemenu()
            self.mainAgent.run(self.getLocationAt(clickpoint) )

        if (evt.getButton() == fife.MouseEvent.RIGHT):
            location = self.getLocationAt(clickpoint)
            instances = self.getInstancesAt(clickpoint)
            #print "selected instances on agent layer: ", [i.getObject().getId() for i in instances]
            if instances:
                self.show_instancemenu(clickpoint, location, instances[0])
            else:
                self.show_instancemenu(clickpoint, location, None)

    def mouseMoved(self, evt):
        if not self.girl or self.girl.dead:
            return
        renderer = fife.InstanceRenderer.getInstance(self.cameras['main'])
        renderer.removeAllOutlines()

        pt = fife.ScreenPoint(evt.getX(), evt.getY())
        instances = self.getInstancesAt(pt);
        agent_names = set([y.agent.getObject().getId() for _, y in self.instance_to_agent.iteritems()])
        agent_names.add('flask_map')
        agent_names.add('coins_map')
        for i in instances:
            aid = i.getObject().getId() 
            me = self.mainAgent.agent.getObject().getId()
            if aid in agent_names and aid != me:
                renderer.addOutlined(i, 173, 255, 47, 2)

    def lightIntensity(self, value):
        if self.light_intensity+value <= 1 and self.light_intensity+value >= 0:
            self.light_intensity = self.light_intensity + value

            if self.lightmodel == 1:
                self.cameras['main'].setLightingColor(self.light_intensity, self.light_intensity, self.light_intensity)

    def lightSourceIntensity(self, value):
        if self.light_sources+value <= 255 and self.light_sources+value >= 0:
            self.light_sources = self.light_sources+value
            renderer = fife.LightRenderer.getInstance(self.cameras['main'])

            renderer.removeAll("beekeeper_simple_light")
            renderer.removeAll("boy")
            renderer.removeAll("girl_simple_light")

            if self.lightmodel == 1:
                node = fife.RendererNode(self.boy.agent)
                renderer.addSimpleLight("boy", node, self.light_sources, 64, 32, 1, 1, 255, 255, 255)

                node = fife.RendererNode(self.girl.agent)       
                renderer.addSimpleLight("girl_simple_light", node, self.light_sources, 64, 32, 1, 1, 255, 255, 255)

                for beekeeper in self.beekeepers:
                    node = fife.RendererNode(beekeeper.agent)
                    renderer.addSimpleLight("beekeeper_simple_light", node, self.light_sources, 120, 32, 1, 1, 255, 255, 255)       

    def onConsoleCommand(self, command):
        result = ''
        try:
            result = str(eval(command))
        except Exception, e:
            result = str(e)
        return result
コード例 #7
0
ファイル: world.py プロジェクト: mvbarracuda/parpg
class World(EventListenerBase):
	def __init__(self, engine):
		super(World, self).__init__(engine, regMouse=True, regKeys=True)
		self.engine = engine
		self.eventmanager = engine.getEventManager()
		self.model = engine.getModel()
		self.view = self.engine.getView()
		self.filename = ''
		self.pump_ctr = 0 # for testing purposis
		self.ctrldown = False
		self.instancemenu = None
		self.instance_to_agent = {}
		self.dynamic_widgets = {}

	def show_instancemenu(self, clickpoint, instance):
		if instance.getFifeId() == self.hero.agent.getFifeId():
			return

		dynamicbuttons = ('moveButton', 'talkButton', 'kickButton', 'inspectButton')
		if not self.instancemenu:
			self.instancemenu = pychan.loadXML('gui/instancemenu.xml')
			self.instancemenu.mapEvents({
				'moveButton' : self.onMoveButtonPress,
				'talkButton' : self.onTalkButtonPress,
				'kickButton' : self.onKickButtonPress,
				'inspectButton' : self.onInspectButtonPress,
			})
			for btn in dynamicbuttons:
				self.dynamic_widgets[btn] = self.instancemenu.findChild(name=btn)
		for btn in dynamicbuttons:
			try:
				self.instancemenu.removeChild(self.dynamic_widgets[btn])
			except pychan.exceptions.RuntimeError:
				pass

		self.instancemenu.clickpoint = clickpoint
		self.instancemenu.instance = instance

		self.instancemenu.addChild(self.dynamic_widgets['inspectButton'])
		target_distance = self.hero.agent.getLocationRef().getLayerDistanceTo(instance.getLocationRef())
		if target_distance > 3.0:
			self.instancemenu.addChild(self.dynamic_widgets['moveButton'])
		else:
			if self.instance_to_agent.has_key(instance.getFifeId()):
				self.instancemenu.addChild(self.dynamic_widgets['talkButton'])
				self.instancemenu.addChild(self.dynamic_widgets['kickButton'])
		self.instancemenu.position = (clickpoint.x, clickpoint.y)
		self.instancemenu.show()

	def hide_instancemenu(self):
		if self.instancemenu:
			self.instancemenu.hide()

	def reset(self):
		self.map, self.agentlayer = None, None
		self.cameras = {}
		self.hero, self.girl, self.clouds, self.beekeepers = None, None, [], []
		self.cur_cam2_x, self.initial_cam2_x, self.cam2_scrolling_right = 0, 0, True
		self.target_rotation = 0
		self.instance_to_agent = {}

	def load(self, filename):
		self.filename = filename
		self.reset()
		self.map = loadMapFile(filename, self.engine)
		self.maplistener = MapListener(self.map)

		self.agentlayer = self.map.getLayer('TechdemoMapGroundObjectLayer')
		self.hero = Hero(self.model, 'PC', self.agentlayer)
		self.instance_to_agent[self.hero.agent.getFifeId()] = self.hero
		self.hero.start()

		self.girl = Girl(self.model, 'NPC:girl', self.agentlayer)
		self.instance_to_agent[self.girl.agent.getFifeId()] = self.girl
		self.girl.start()

		self.beekeepers = create_anonymous_agents(self.model, 'beekeeper', self.agentlayer, Beekeeper)
		for beekeeper in self.beekeepers:
			self.instance_to_agent[beekeeper.agent.getFifeId()] = beekeeper
			beekeeper.start()

		cloudlayer = self.map.getLayer('TechdemoMapTileLayer')
		self.clouds = create_anonymous_agents(self.model, 'Cloud', cloudlayer, Cloud)
		for cloud in self.clouds:
			cloud.start(0.1, 0.05)

		for cam in self.view.getCameras():
			self.cameras[cam.getId()] = cam
		self.cameras['main'].attach(self.hero.agent)

		self.view.resetRenderers()
		renderer = fife.FloatingTextRenderer.getInstance(self.cameras['main'])
		textfont = self.engine.getGuiManager().createFont('fonts/rpgfont.png', 0, str(TDS.readSetting("FontGlyphs", strip=False)));
		renderer.changeDefaultFont(textfont)

		renderer = fife.FloatingTextRenderer.getInstance(self.cameras['small'])
		renderer.changeDefaultFont(None)

		renderer = self.cameras['main'].getRenderer('CoordinateRenderer')
		renderer.clearActiveLayers()
		renderer.addActiveLayer(self.map.getLayer(str(TDS.readSetting("CoordinateLayerName"))))

		renderer = self.cameras['main'].getRenderer('QuadTreeRenderer')
		renderer.setEnabled(True)
		renderer.clearActiveLayers()
		if str(TDS.readSetting("QuadTreeLayerName")):
			renderer.addActiveLayer(self.map.getLayer(str(TDS.readSetting("QuadTreeLayerName"))))

		self.cameras['small'].getLocationRef().setExactLayerCoordinates( fife.ExactModelCoordinate( 40.0, 40.0, 0.0 ))
		self.initial_cam2_x = self.cameras['small'].getLocation().getExactLayerCoordinates().x
		self.cur_cam2_x = self.initial_cam2_x
		self.cam2_scrolling_right = True
		self.cameras['small'].setEnabled(False)

		self.target_rotation = self.cameras['main'].getRotation()

	def save(self, filename):
		saveMapFile(filename, self.engine, self.map)

	def keyPressed(self, evt):
		keyval = evt.getKey().getValue()
		keystr = evt.getKey().getAsString().lower()
		if keystr == 't':
			r = self.cameras['main'].getRenderer('GridRenderer')
			r.setEnabled(not r.isEnabled())
		elif keystr == 'c':
			r = self.cameras['main'].getRenderer('CoordinateRenderer')
			r.setEnabled(not r.isEnabled())
		elif keystr == 's':
			c = self.cameras['small']
			c.setEnabled(not c.isEnabled())
		elif keystr == 'r':
			pass
#			self.model.deleteMaps()
#			self.metamodel.deleteDatasets()
#			self.view.clearCameras()
#			self.load(self.filename)
		elif keystr == 'o':
			self.target_rotation = (self.target_rotation + 90) % 360
		elif keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
			self.ctrldown = True

	def keyReleased(self, evt):
		keyval = evt.getKey().getValue()
		if keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
			self.ctrldown = False

	def mouseWheelMovedUp(self, evt):
		if self.ctrldown:
			self.cameras['main'].setZoom(self.cameras['main'].getZoom() * 1.05)

	def mouseWheelMovedDown(self, evt):
		if self.ctrldown:
			self.cameras['main'].setZoom(self.cameras['main'].getZoom() / 1.05)

	def changeRotation(self):
		currot = self.cameras['main'].getRotation()
		if self.target_rotation != currot:
			self.cameras['main'].setRotation((currot + 5) % 360)

	def mousePressed(self, evt):
		if evt.isConsumedByWidgets():
			return

		clickpoint = fife.ScreenPoint(evt.getX(), evt.getY())
		if (evt.getButton() == fife.MouseEvent.LEFT):
			self.hide_instancemenu()
			target_mapcoord = self.cameras['main'].toMapCoordinates(clickpoint, False)
			target_mapcoord.z = 0
			l = fife.Location(self.agentlayer)
			l.setMapCoordinates(target_mapcoord)
			self.hero.run(l)

		if (evt.getButton() == fife.MouseEvent.RIGHT):
			instances = self.cameras['main'].getMatchingInstances(clickpoint, self.agentlayer)
			print "selected instances on agent layer: ", [i.getObject().getId() for i in instances]
			if instances:
				self.show_instancemenu(clickpoint, instances[0])

	def mouseMoved(self, evt):
		renderer = fife.InstanceRenderer.getInstance(self.cameras['main'])
		renderer.removeAllOutlines()

		pt = fife.ScreenPoint(evt.getX(), evt.getY())
		instances = self.cameras['main'].getMatchingInstances(pt, self.agentlayer);
		for i in instances:
			if i.getObject().getId() in ('girl', 'beekeeper'):
				renderer.addOutlined(i, 173, 255, 47, 2)

	def onConsoleCommand(self, command):
		result = ''
		try:
			result = str(eval(command))
		except:
			pass
		return result

	def onMoveButtonPress(self):
		self.hide_instancemenu()
		self.hero.run(self.instancemenu.instance.getLocationRef())

	def onTalkButtonPress(self):
		self.hide_instancemenu()
		instance = self.instancemenu.instance
		self.hero.talk(instance.getLocationRef())
		if instance.getObject().getId() == 'beekeeper':
			beekeeperTexts = TDS.readSetting("beekeeperTexts", type='list', text=True)
			txtindex = random.randint(0, len(beekeeperTexts) - 1)
			instance.say(beekeeperTexts[txtindex], 5000)
		if instance.getObject().getId() == 'girl':
			girlTexts = TDS.readSetting("girlTexts", type='list', text=True)
			txtindex = random.randint(0, len(girlTexts) - 1)
			instance.say(girlTexts[txtindex], 5000)

	def onKickButtonPress(self):
		self.hide_instancemenu()
		self.hero.kick(self.instancemenu.instance.getLocationRef())
		self.instancemenu.instance.say('Hey!', 1000)

	def onInspectButtonPress(self):
		self.hide_instancemenu()
		inst = self.instancemenu.instance
		saytext = ['Engine told me that this instance has']
		if inst.getId():
			saytext.append(' name %s,' % inst.getId())
		saytext.append(' ID %s and' % inst.getFifeId())
		saytext.append(' object name %s' % inst.getObject().getId())
		self.hero.agent.say('\n'.join(saytext), 3500)

	def pump(self):
		if self.cameras['small'].isEnabled():
			loc = self.cameras['small'].getLocation()
			c = loc.getExactLayerCoordinatesRef()
			if self.cam2_scrolling_right:
				self.cur_cam2_x = c.x = c.x+0.1
				if self.cur_cam2_x > self.initial_cam2_x+10:
					self.cam2_scrolling_right = False
			else:
				self.cur_cam2_x = c.x = c.x-0.1
				if self.cur_cam2_x < self.initial_cam2_x-10:
					self.cam2_scrolling_right = True
			self.cameras['small'].setLocation(loc)
		self.changeRotation()
		self.pump_ctr += 1
コード例 #8
0
ファイル: world.py プロジェクト: karottenreibe/FIFE
class World(EventListenerBase):
	"""
	The world!

	This class handles:
	  setup of map view (cameras ...)
	  loading the map
	  GUI for right clicks
	  handles mouse/key events which aren't handled by the GUI.
	   ( by inheriting from EventlistenerBase )

	That's obviously too much, and should get factored out.
	"""
	def __init__(self, engine):
		super(World, self).__init__(engine, regMouse=True, regKeys=True)
		self.engine = engine
		self.eventmanager = engine.getEventManager()
		self.model = engine.getModel()
		self.filename = ''
		self.pump_ctr = 0 # for testing purposis
		self.ctrldown = False
		self.instancemenu = None
		self.instance_to_agent = {}
		self.dynamic_widgets = {}

		self.light_intensity = 1
		self.light_sources = 0
		self.lightmodel = int(TDS.get("FIFE", "Lighting"))

		self.soundmanager = SoundManager(self.engine)
		self.music = None

	def show_instancemenu(self, clickpoint, instance):
		"""
		Build and show a popupmenu for an instance that the player
		clicked on. The available actions are dynamically added to
		the menu (and mapped to the onXYZ functions).
		"""
		if instance.getFifeId() == self.hero.agent.getFifeId():
			return

		# Create the popup.
		self.build_instancemenu()
		self.instancemenu.clickpoint = clickpoint
		self.instancemenu.instance = instance

		# Add the buttons according to circumstances.
		self.instancemenu.addChild(self.dynamic_widgets['inspectButton'])
		target_distance = self.hero.agent.getLocationRef().getLayerDistanceTo(instance.getLocationRef())
		if target_distance > 3.0:
			self.instancemenu.addChild(self.dynamic_widgets['moveButton'])
		else:
			if self.instance_to_agent.has_key(instance.getFifeId()):
				self.instancemenu.addChild(self.dynamic_widgets['talkButton'])
				self.instancemenu.addChild(self.dynamic_widgets['kickButton'])
		# And show it :)
		self.instancemenu.position = (clickpoint.x, clickpoint.y)
		self.instancemenu.show()

	def build_instancemenu(self):
		"""
		Just loads the menu from an XML file
		and hooks the events up.
		The buttons are removed and later re-added if appropiate.
		"""
		self.hide_instancemenu()
		dynamicbuttons = ('moveButton', 'talkButton', 'kickButton', 'inspectButton')
		self.instancemenu = pychan.loadXML('gui/instancemenu.xml')
		self.instancemenu.mapEvents({
			'moveButton' : self.onMoveButtonPress,
			'talkButton' : self.onTalkButtonPress,
			'kickButton' : self.onKickButtonPress,
			'inspectButton' : self.onInspectButtonPress,
		})
		for btn in dynamicbuttons:
			self.dynamic_widgets[btn] = self.instancemenu.findChild(name=btn)
		self.instancemenu.removeAllChildren()

	def hide_instancemenu(self):
		if self.instancemenu:
			self.instancemenu.hide()

	def reset(self):
		"""
		Clear the agent information and reset the moving secondary camera state.
		"""
		if self.music:
			self.music.stop()
			
		self.map, self.agentlayer = None, None
		self.cameras = {}
		self.hero, self.girl, self.clouds, self.beekeepers = None, None, [], []
		self.cur_cam2_x, self.initial_cam2_x, self.cam2_scrolling_right = 0, 0, True
		self.target_rotation = 0
		self.instance_to_agent = {}

	def load(self, filename):
		"""
		Load a xml map and setup agents and cameras.
		"""
		
		self.filename = filename
		self.reset()
		loader = fife.MapLoader(self.engine.getModel(), 
								self.engine.getVFS(), 
								self.engine.getImageManager(), 
								self.engine.getRenderBackend())
								
		if loader.isLoadable(filename):
			self.map = loader.load(filename)

		self.initAgents()
		self.initCameras()

		#Set background color
		self.engine.getRenderBackend().setBackgroundColor(80,80,255)

		if int(TDS.get("FIFE", "PlaySounds")):
			# play track as background music
			self.music = self.soundmanager.createSoundEmitter('music/rio_de_hola.ogg')
			self.music.looping = True
			self.music.gain = 128.0
			self.music.play()
			
			self.waves = self.soundmanager.createSoundEmitter('sounds/waves.ogg')
			self.waves.looping = True
			self.waves.gain = 16.0
			self.waves.play()

	def initAgents(self):
		"""
		Setup agents.

		For this techdemo we have a very simple 'active things on the map' model,
		which is called agents. All rio maps will have a separate layer for them.

		Note that we keep a mapping from map instances (C++ model of stuff on the map)
		to the python agents for later reference.
		"""
		self.agentlayer = self.map.getLayer('TechdemoMapGroundObjectLayer')
		self.hero = Hero(TDS, self.model, 'PC', self.agentlayer)
		self.instance_to_agent[self.hero.agent.getFifeId()] = self.hero
		self.hero.start()

		self.girl = Girl(TDS, self.model, 'NPC:girl', self.agentlayer)
		self.instance_to_agent[self.girl.agent.getFifeId()] = self.girl
		self.girl.start()

		self.beekeepers = create_anonymous_agents(TDS, self.model, 'beekeeper', self.agentlayer, Beekeeper)
		for beekeeper in self.beekeepers:
			self.instance_to_agent[beekeeper.agent.getFifeId()] = beekeeper
			beekeeper.start()

		# Clouds are currently defunct.
		cloudlayer = self.map.getLayer('TechdemoMapTileLayer')
		self.clouds = create_anonymous_agents(TDS, self.model, 'Cloud', cloudlayer, Cloud)
		for cloud in self.clouds:
			cloud.start(0.1, 0.05)


	def initCameras(self):
		"""
		Before we can actually see something on screen we have to specify the render setup.
		This is done through Camera objects which offer a viewport on the map.

		For this techdemo two cameras are used. One follows the hero(!) via 'attach'
		the other one scrolls around a bit (see the pump function).
		"""
		camera_prefix = self.filename.rpartition('.')[0] # Remove file extension
		camera_prefix = camera_prefix.rpartition('/')[2] # Remove path
		camera_prefix += '_'
		
		for cam in self.map.getCameras():
			camera_id = cam.getId().replace(camera_prefix, '')
			self.cameras[camera_id] = cam
			cam.resetRenderers()
			
		self.cameras['main'].attach(self.hero.agent)

		# Floating text renderers currntly only support one font.
		# ... so we set that up.
		# You'll se that for our demo we use a image font, so we have to specify the font glyphs
		# for that one.
		renderer = fife.FloatingTextRenderer.getInstance(self.cameras['main'])
		textfont = pychan.manager.hook.guimanager.createFont('fonts/rpgfont.png', 0, str(TDS.get("FIFE", "FontGlyphs")));
		renderer.setFont(textfont)
		renderer.activateAllLayers(self.map)
		renderer.setBackground(100, 255, 100, 165)
		renderer.setBorder(50, 255, 50)
		renderer.setEnabled(True)
		
		# Activate the grid renderer on all layers
		renderer = self.cameras['main'].getRenderer('GridRenderer')
		renderer.activateAllLayers(self.map)
		
		# The small camera shouldn't be cluttered by the 'humm di dums' of our hero.
		# So we disable the renderer simply by setting its font to None.
		renderer = fife.FloatingTextRenderer.getInstance(self.cameras['small'])
		renderer.setFont(None)

		# The following renderers are used for debugging.
		# Note that by default ( that is after calling View.resetRenderers or Camera.resetRenderers )
		# renderers will be handed all layers. That's handled here.
		renderer = fife.CoordinateRenderer.getInstance(self.cameras['main'])
		renderer.setFont(textfont)
		renderer.clearActiveLayers()
		renderer.addActiveLayer(self.map.getLayer(str(TDS.get("rio", "CoordinateLayerName"))))

		renderer = self.cameras['main'].getRenderer('QuadTreeRenderer')
		renderer.setEnabled(True)
		renderer.clearActiveLayers()
		if str(TDS.get("rio", "QuadTreeLayerName")):
			renderer.addActiveLayer(self.map.getLayer(str(TDS.get("rio", "QuadTreeLayerName"))))

		# If Light is enabled in settings then init the lightrenderer.
		if self.lightmodel != 0:
			renderer = fife.LightRenderer.getInstance(self.cameras['main'])
			renderer.setEnabled(True)
			renderer.clearActiveLayers()
			renderer.addActiveLayer(self.map.getLayer('TechdemoMapGroundObjectLayer'))
			
		# Set up the second camera
		# NOTE: We need to explicitly call setLocation, there's a bit of a messup in the Camera code.
		self.cameras['small'].setLocation(self.hero.agent.getLocation())
		self.cameras['small'].attach(self.girl.agent)
		
		self.target_rotation = self.cameras['main'].getRotation()


	def save(self, filename):
		saveMapFile(filename, self.engine, self.map)

	def getInstancesAt(self, clickpoint):
		"""
		Query the main camera for instances on our active(agent) layer.
		"""
		return self.cameras['main'].getMatchingInstances(clickpoint, self.agentlayer)

	def getLocationAt(self, clickpoint):
		"""
		Query the main camera for the Map location (on the agent layer)
		that a screen point refers to.
		"""
		target_mapcoord = self.cameras['main'].toMapCoordinates(clickpoint, False)
		target_mapcoord.z = 0
		location = fife.Location(self.agentlayer)
		location.setMapCoordinates(target_mapcoord)
		return location

	def keyPressed(self, evt):
		keyval = evt.getKey().getValue()
		keystr = evt.getKey().getAsString().lower()
		if keystr == 't':
			r = self.cameras['main'].getRenderer('GridRenderer')
			r.setEnabled(not r.isEnabled())
		elif keystr == 'c':
			r = self.cameras['main'].getRenderer('CoordinateRenderer')
			r.setEnabled(not r.isEnabled())
		elif keystr == 's':
			c = self.cameras['small']
			c.setEnabled(not c.isEnabled())
		elif keystr == 'r':
			self.model.deleteMaps()
			self.load(self.filename)
		elif keystr == 'o':
			self.target_rotation = (self.target_rotation + 90) % 360
		elif keystr == '2':
			self.lightIntensity(0.1)
		elif keystr == '1':
			self.lightIntensity(-0.1)
		elif keystr == '5':
			self.lightSourceIntensity(25)
		elif keystr == '4':
			self.lightSourceIntensity(-25)
		elif keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
			self.ctrldown = True

	def keyReleased(self, evt):
		keyval = evt.getKey().getValue()
		if keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
			self.ctrldown = False

	def mouseWheelMovedUp(self, evt):
		if self.ctrldown:
			self.cameras['main'].setZoom(self.cameras['main'].getZoom() * 1.05)

	def mouseWheelMovedDown(self, evt):
		if self.ctrldown:
			self.cameras['main'].setZoom(self.cameras['main'].getZoom() / 1.05)

	def changeRotation(self):
		"""
		Smoothly change the main cameras rotation until
		the current target rotation is reached.
		"""
		currot = self.cameras['main'].getRotation()
		if self.target_rotation != currot:
			self.cameras['main'].setRotation((currot + 5) % 360)

	def mousePressed(self, evt):
		if evt.isConsumedByWidgets():
			return

		clickpoint = fife.ScreenPoint(evt.getX(), evt.getY())
		if (evt.getButton() == fife.MouseEvent.LEFT):
			self.hide_instancemenu()
			self.hero.run( self.getLocationAt(clickpoint) )

		if (evt.getButton() == fife.MouseEvent.RIGHT):
			instances = self.getInstancesAt(clickpoint)
			print "selected instances on agent layer: ", [i.getObject().getId() for i in instances]
			if instances:
				self.show_instancemenu(clickpoint, instances[0])

	def mouseMoved(self, evt):
		renderer = fife.InstanceRenderer.getInstance(self.cameras['main'])
		renderer.removeAllOutlines()

		pt = fife.ScreenPoint(evt.getX(), evt.getY())
		instances = self.getInstancesAt(pt);
		for i in instances:
			if i.getObject().getId() in ('girl', 'beekeeper'):
				renderer.addOutlined(i, 173, 255, 47, 2)

	def lightIntensity(self, value):
		if self.light_intensity+value <= 1 and self.light_intensity+value >= 0:
			self.light_intensity = self.light_intensity + value

			if self.lightmodel == 1:
				self.cameras['main'].setLightingColor(self.light_intensity, self.light_intensity, self.light_intensity)

	def lightSourceIntensity(self, value):
		if self.light_sources+value <= 255 and self.light_sources+value >= 0:
			self.light_sources = self.light_sources+value
			renderer = fife.LightRenderer.getInstance(self.cameras['main'])

			renderer.removeAll("beekeeper_simple_light")
			renderer.removeAll("hero_simple_light")
			renderer.removeAll("girl_simple_light")

			if self.lightmodel == 1:
				node = fife.RendererNode(self.hero.agent)
				renderer.addSimpleLight("hero_simple_light", node, self.light_sources, 64, 32, 1, 1, 255, 255, 255)

				node = fife.RendererNode(self.girl.agent)		
				renderer.addSimpleLight("girl_simple_light", node, self.light_sources, 64, 32, 1, 1, 255, 255, 255)

				for beekeeper in self.beekeepers:
					node = fife.RendererNode(beekeeper.agent)
					renderer.addSimpleLight("beekeeper_simple_light", node, self.light_sources, 120, 32, 1, 1, 255, 255, 255)		

	def onConsoleCommand(self, command):
		result = ''
		try:
			result = str(eval(command))
		except Exception, e:
			result = str(e)
		return result
コード例 #9
0
class World(EventListenerBase):
	"""
	The world!

	This class handles:
	  setup of map view (cameras ...)
	  loading the map
	  GUI for right clicks
	  handles mouse/key events which aren't handled by the GUI.
	   ( by inheriting from EventlistenerBase )

	That's obviously too much, and should get factored out.
	"""
	def __init__(self, engine):
		super(World, self).__init__(engine, regMouse=True, regKeys=True)
		self.engine = engine
		self.eventmanager = engine.getEventManager()
		self.model = engine.getModel()
		self.filename = ''
		self.pump_ctr = 0 # for testing purposis
		self.ctrldown = False
		self.instancemenu = None
		self.instance_to_agent = {}
		self.dynamic_widgets = {}

		self.light_intensity = 1
		self.light_sources = 0
		self.lightmodel = int(TDS.get("FIFE", "Lighting"))

		self.soundmanager = SoundManager(self.engine)
		self.music = None

	def show_instancemenu(self, clickpoint, instance):
		"""
		Build and show a popupmenu for an instance that the player
		clicked on. The available actions are dynamically added to
		the menu (and mapped to the onXYZ functions).
		"""
		if instance.getFifeId() == self.hero.agent.getFifeId():
			return

		# Create the popup.
		self.build_instancemenu()
		self.instancemenu.clickpoint = clickpoint
		self.instancemenu.instance = instance

		# Add the buttons according to circumstances.
		self.instancemenu.addChild(self.dynamic_widgets['inspectButton'])
		target_distance = self.hero.agent.getLocationRef().getLayerDistanceTo(instance.getLocationRef())
		if target_distance > 3.0:
			self.instancemenu.addChild(self.dynamic_widgets['moveButton'])
		else:
			if self.instance_to_agent.has_key(instance.getFifeId()):
				self.instancemenu.addChild(self.dynamic_widgets['talkButton'])
				self.instancemenu.addChild(self.dynamic_widgets['kickButton'])
		# And show it :)
		self.instancemenu.position = (clickpoint.x, clickpoint.y)
		self.instancemenu.show()

	def build_instancemenu(self):
		"""
		Just loads the menu from an XML file
		and hooks the events up.
		The buttons are removed and later re-added if appropiate.
		"""
		self.hide_instancemenu()
		dynamicbuttons = ('moveButton', 'talkButton', 'kickButton', 'inspectButton')
		self.instancemenu = pychan.loadXML('gui/instancemenu.xml')
		self.instancemenu.mapEvents({
			'moveButton' : self.onMoveButtonPress,
			'talkButton' : self.onTalkButtonPress,
			'kickButton' : self.onKickButtonPress,
			'inspectButton' : self.onInspectButtonPress,
		})
		for btn in dynamicbuttons:
			self.dynamic_widgets[btn] = self.instancemenu.findChild(name=btn)
		self.instancemenu.removeAllChildren()

	def hide_instancemenu(self):
		if self.instancemenu:
			self.instancemenu.hide()

	def reset(self):
		"""
		Clear the agent information and reset the moving secondary camera state.
		"""
		if self.music:
			self.music.stop()
			
		self.map, self.agentlayer = None, None
		self.cameras = {}
		self.hero, self.girl, self.clouds, self.beekeepers = None, None, [], []
		self.cur_cam2_x, self.initial_cam2_x, self.cam2_scrolling_right = 0, 0, True
		self.target_rotation = 0
		self.instance_to_agent = {}

	def load(self, filename):
		"""
		Load a xml map and setup agents and cameras.
		"""
		
		self.filename = filename
		self.reset()
		loader = fife.MapLoader(self.engine.getModel(), 
								self.engine.getVFS(), 
								self.engine.getImageManager(), 
								self.engine.getRenderBackend())
								
		if loader.isLoadable(filename):
			self.map = loader.load(filename)

		self.initAgents()
		self.initCameras()

		#Set background color
		self.engine.getRenderBackend().setBackgroundColor(80,80,255)

		if int(TDS.get("FIFE", "PlaySounds")):
			# play track as background music
			self.music = self.soundmanager.createSoundEmitter('music/rio_de_hola.ogg')
			self.music.looping = True
			self.music.gain = 128.0
			self.music.play()
			
			self.waves = self.soundmanager.createSoundEmitter('sounds/waves.ogg')
			self.waves.looping = True
			self.waves.gain = 16.0
			self.waves.play()

	def initAgents(self):
		"""
		Setup agents.

		For this techdemo we have a very simple 'active things on the map' model,
		which is called agents. All rio maps will have a separate layer for them.

		Note that we keep a mapping from map instances (C++ model of stuff on the map)
		to the python agents for later reference.
		"""
		self.agentlayer = self.map.getLayer('TechdemoMapGroundObjectLayer')
		self.hero = Hero(TDS, self.model, 'PC', self.agentlayer)
		self.instance_to_agent[self.hero.agent.getFifeId()] = self.hero
		self.hero.start()

		self.girl = Girl(TDS, self.model, 'NPC:girl', self.agentlayer)
		self.instance_to_agent[self.girl.agent.getFifeId()] = self.girl
		self.girl.start()

		# Fog of War stuff
		#self.hero.agent.setVisitor(True)
		#self.hero.agent.setVisitorRadius(2)
		#self.girl.agent.setVisitor(True)
		#self.girl.agent.setVisitorRadius(1)

		self.beekeepers = create_anonymous_agents(TDS, self.model, 'beekeeper', self.agentlayer, Beekeeper)
		for beekeeper in self.beekeepers:
			self.instance_to_agent[beekeeper.agent.getFifeId()] = beekeeper
			beekeeper.start()

		# Clouds are currently defunct.
		cloudlayer = self.map.getLayer('TechdemoMapTileLayer')
		self.clouds = create_anonymous_agents(TDS, self.model, 'Cloud', cloudlayer, Cloud)
		for cloud in self.clouds:
			cloud.start(0.1, 0.05)


	def initCameras(self):
		"""
		Before we can actually see something on screen we have to specify the render setup.
		This is done through Camera objects which offer a viewport on the map.

		For this techdemo two cameras are used. One follows the hero(!) via 'attach'
		the other one scrolls around a bit (see the pump function).
		"""
		camera_prefix = self.filename.rpartition('.')[0] # Remove file extension
		camera_prefix = camera_prefix.rpartition('/')[2] # Remove path
		camera_prefix += '_'
		
		for cam in self.map.getCameras():
			camera_id = cam.getId().replace(camera_prefix, '')
			self.cameras[camera_id] = cam
			cam.resetRenderers()
			
		self.cameras['main'].attach(self.hero.agent)

		# Floating text renderers currntly only support one font.
		# ... so we set that up.
		# You'll se that for our demo we use a image font, so we have to specify the font glyphs
		# for that one.
		renderer = fife.FloatingTextRenderer.getInstance(self.cameras['main'])
		textfont = get_manager().createFont('fonts/rpgfont.png', 0, str(TDS.get("FIFE", "FontGlyphs")));
		renderer.setFont(textfont)
		renderer.activateAllLayers(self.map)
		renderer.setBackground(100, 255, 100, 165)
		renderer.setBorder(50, 255, 50)
		renderer.setEnabled(True)
		
		# Activate the grid renderer on all layers
		renderer = self.cameras['main'].getRenderer('GridRenderer')
		renderer.activateAllLayers(self.map)
		
		# The small camera shouldn't be cluttered by the 'humm di dums' of our hero.
		# So we disable the renderer simply by setting its font to None.
		renderer = fife.FloatingTextRenderer.getInstance(self.cameras['small'])
		renderer.setFont(None)

		# The following renderers are used for debugging.
		# Note that by default ( that is after calling View.resetRenderers or Camera.resetRenderers )
		# renderers will be handed all layers. That's handled here.
		renderer = fife.CoordinateRenderer.getInstance(self.cameras['main'])
		renderer.setFont(textfont)
		renderer.clearActiveLayers()
		renderer.addActiveLayer(self.map.getLayer(str(TDS.get("rio", "CoordinateLayerName"))))

		renderer = self.cameras['main'].getRenderer('QuadTreeRenderer')
		renderer.setEnabled(True)
		renderer.clearActiveLayers()
		if str(TDS.get("rio", "QuadTreeLayerName")):
			renderer.addActiveLayer(self.map.getLayer(str(TDS.get("rio", "QuadTreeLayerName"))))

		# If Light is enabled in settings then init the lightrenderer.
		if self.lightmodel != 0:
			renderer = fife.LightRenderer.getInstance(self.cameras['main'])
			renderer.setEnabled(True)
			renderer.clearActiveLayers()
			renderer.addActiveLayer(self.map.getLayer('TechdemoMapGroundObjectLayer'))

		# Fog of War stuff
		renderer = fife.CellRenderer.getInstance(self.cameras['main'])
		renderer.setEnabled(True)
		renderer.clearActiveLayers()
		renderer.addActiveLayer(self.map.getLayer('TechdemoMapGroundObjectLayer'))
		concimg = self.engine.getImageManager().load("misc/black_cell.png")
		maskimg = self.engine.getImageManager().load("misc/mask_cell.png")
		renderer.setConcealImage(concimg)
		renderer.setMaskImage(maskimg)
		renderer.setFogOfWarLayer(self.map.getLayer('TechdemoMapGroundObjectLayer'))
		
		#disable FoW by default.  Users can turn it on with the 'f' key.
		renderer.setEnabledFogOfWar(False)
		
		#renderer.setEnabledBlocking(True)

		# Set up the second camera
		# NOTE: We need to explicitly call setLocation, there's a bit of a messup in the Camera code.
		self.cameras['small'].setLocation(self.hero.agent.getLocation())
		self.cameras['small'].attach(self.girl.agent)
		
		self.target_rotation = self.cameras['main'].getRotation()


	def save(self, filename):
		saveMapFile(filename, self.engine, self.map)

	def getInstancesAt(self, clickpoint):
		"""
		Query the main camera for instances on our active(agent) layer.
		"""
		return self.cameras['main'].getMatchingInstances(clickpoint, self.agentlayer)

	def getLocationAt(self, clickpoint):
		"""
		Query the main camera for the Map location (on the agent layer)
		that a screen point refers to.
		"""
		target_mapcoord = self.cameras['main'].toMapCoordinates(clickpoint, False)
		target_mapcoord.z = 0
		location = fife.Location(self.agentlayer)
		location.setMapCoordinates(target_mapcoord)
		return location

	def keyPressed(self, evt):
		keyval = evt.getKey().getValue()
		keystr = evt.getKey().getAsString().lower()
		if keystr == 't':
			r = self.cameras['main'].getRenderer('GridRenderer')
			r.setEnabled(not r.isEnabled())
		elif keystr == 'c':
			r = self.cameras['main'].getRenderer('CoordinateRenderer')
			r.setEnabled(not r.isEnabled())
		elif keystr == 's':
			c = self.cameras['small']
			c.setEnabled(not c.isEnabled())
		elif keystr == 'r':
			self.model.deleteMaps()
			self.load(self.filename)
		elif keystr == 'f':
			renderer = fife.CellRenderer.getInstance(self.cameras['main'])
			renderer.setEnabledFogOfWar(not renderer.isEnabledFogOfWar())
			self.cameras['main'].refresh()
		elif keystr == 'o':
			self.target_rotation = (self.target_rotation + 90) % 360
		elif keystr == '2':
			self.lightIntensity(0.1)
		elif keystr == '1':
			self.lightIntensity(-0.1)
		elif keystr == '5':
			self.lightSourceIntensity(25)
		elif keystr == '4':
			self.lightSourceIntensity(-25)
		elif keystr == '0' or keystr == fife.Key.NUM_0:
			if self.ctrldown:
				self.cameras['main'].setZoom(1.0)
		elif keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
			self.ctrldown = True

	def keyReleased(self, evt):
		keyval = evt.getKey().getValue()
		if keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
			self.ctrldown = False

	def mouseWheelMovedUp(self, evt):
		if self.ctrldown:
			self.cameras['main'].setZoom(self.cameras['main'].getZoom() * 1.05)

	def mouseWheelMovedDown(self, evt):
		if self.ctrldown:
			self.cameras['main'].setZoom(self.cameras['main'].getZoom() / 1.05)

	def changeRotation(self):
		"""
		Smoothly change the main cameras rotation until
		the current target rotation is reached.
		"""
		currot = self.cameras['main'].getRotation()
		if self.target_rotation != currot:
			self.cameras['main'].setRotation((currot + 5) % 360)

	def mousePressed(self, evt):
		if evt.isConsumedByWidgets():
			return

		clickpoint = fife.ScreenPoint(evt.getX(), evt.getY())
		if (evt.getButton() == fife.MouseEvent.LEFT):
			self.hide_instancemenu()
			self.hero.run( self.getLocationAt(clickpoint) )

		if (evt.getButton() == fife.MouseEvent.RIGHT):
			instances = self.getInstancesAt(clickpoint)
			print "selected instances on agent layer: ", [i.getObject().getId() for i in instances]
			if instances:
				self.show_instancemenu(clickpoint, instances[0])

	def mouseMoved(self, evt):
		renderer = fife.InstanceRenderer.getInstance(self.cameras['main'])
		renderer.removeAllOutlines()

		pt = fife.ScreenPoint(evt.getX(), evt.getY())
		instances = self.getInstancesAt(pt);
		for i in instances:
			if i.getObject().getId() in ('girl', 'beekeeper'):
				renderer.addOutlined(i, 173, 255, 47, 2)

	def lightIntensity(self, value):
		if self.light_intensity+value <= 1 and self.light_intensity+value >= 0:
			self.light_intensity = self.light_intensity + value

			if self.lightmodel == 1:
				self.cameras['main'].setLightingColor(self.light_intensity, self.light_intensity, self.light_intensity)

	def lightSourceIntensity(self, value):
		if self.light_sources+value <= 255 and self.light_sources+value >= 0:
			self.light_sources = self.light_sources+value
			renderer = fife.LightRenderer.getInstance(self.cameras['main'])

			renderer.removeAll("beekeeper_simple_light")
			renderer.removeAll("hero_simple_light")
			renderer.removeAll("girl_simple_light")

			if self.lightmodel == 1:
				node = fife.RendererNode(self.hero.agent)
				renderer.addSimpleLight("hero_simple_light", node, self.light_sources, 64, 32, 1, 1, 255, 255, 255)

				node = fife.RendererNode(self.girl.agent)		
				renderer.addSimpleLight("girl_simple_light", node, self.light_sources, 64, 32, 1, 1, 255, 255, 255)

				for beekeeper in self.beekeepers:
					node = fife.RendererNode(beekeeper.agent)
					renderer.addSimpleLight("beekeeper_simple_light", node, self.light_sources, 120, 32, 1, 1, 255, 255, 255)		

	def onConsoleCommand(self, command):
		result = ''
		try:
			result = str(eval(command))
		except Exception, e:
			result = str(e)
		return result