source: trunk/game/scripts/gamemap.py @ 643

Revision 643, 6.6 KB checked in by beliar, 9 years ago (diff)

Patch by Beliar

  • Removed local_loaders directory. The files/classes in local_loaders are not needed anymore since the changes they contain to the classes from the fife editor are not needed anymore as the agents are in seperate files. Any class that used these files are now using the original files/classes from fife.
  • Property svn:eol-style set to native
Line 
1#!/usr/bin/env python
2
3#   This file is part of PARPG.
4
5#   PARPG is free software: you can redistribute it and/or modify
6#   it under the terms of the GNU General Public License as published by
7#   the Free Software Foundation, either version 3 of the License, or
8#   (at your option) any later version.
9
10#   PARPG is distributed in the hope that it will be useful,
11#   but WITHOUT ANY WARRANTY; without even the implied warranty of
12#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13#   GNU General Public License for more details.
14
15#   You should have received a copy of the GNU General Public License
16#   along with PARPG.  If not, see <http://www.gnu.org/licenses/>.
17
18from fife import fife
19
20from fife.extensions.loaders import loadMapFile
21from scripts.common.utils import loadSettings
22
23
24Settings = loadSettings()
25
26class GameMap(fife.MapChangeListener):
27    """Map class used to flag changes in the map"""
28    def __init__(self, engine, model):
29        # init mapchange listener
30        fife.MapChangeListener.__init__(self)
31        self.map = None
32        self.engine = engine
33        self.model = model
34
35        # init map attributes
36        self.my_cam_id = None
37        self.cameras = {}
38        self.agent_layer = None
39        self.top_layer = None
40        self.fife_model = engine.getModel()
41        self.transitions = []
42        self.cur_cam2_x = 0
43        self.initial_cam2_x = 0
44        self.cam2_scrolling_right = True
45        self.target_rotation = 0
46        self.outline_renderer = None
47       
48    def reset(self):
49        """Reset the model to default settings.
50           @return: None"""
51        # We have to delete the map in Fife.
52        if self.map:
53            self.model.deleteObjects()
54            self.model.deleteMap(self.map)
55        self.transitions = []
56        self.map = None
57        self.agent_layer = None       
58        self.top_layer = None
59        # We have to clear the cameras in the view as well, or we can't reuse
60        # camera names like 'main'
61        #self.view.clearCameras()
62        self.initial_cam2_x = 0
63        self.cam2_scrolling_right = True
64        #self.cameras = {}
65        self.cur_cam2_x = 0
66        self.target_rotation = 0
67        self.outline_renderer = None
68       
69    def makeActive(self):
70        """Makes this map the active one.
71           @return: None"""
72        self.cameras[self.my_cam_id].setEnabled(True)
73       
74    def load(self, filename):
75        """Load a map given the filename.
76           @type filename: String
77           @param filename: Name of map to load
78           @return: None"""
79        self.reset()
80        self.map = loadMapFile(filename, self.engine)
81        self.agent_layer = self.map.getLayer('ObjectLayer')
82        self.top_layer = self.map.getLayer('TopLayer')     
83           
84        # it's possible there's no transition layer
85        size = len('TransitionLayer')
86        for layer in self.map.getLayers():
87            # could be many layers, but hopefully no more than 3
88            if(layer.getId()[:size] == 'TransitionLayer'):
89                self.transitions.append(self.map.getLayer(layer.getId()))
90
91        """ Initialize the camera.
92        Note that if we have more than one camera in a map file
93        we will have to rework how self.my_cam_id works. To make sure
94        the proper camera is set as the 'main' camera.
95        At this point we also set the viewport to the current resolution."""
96        for cam in self.map.getCameras():
97            width = self.engine.getSettings().getScreenWidth()
98            height = self.engine.getSettings().getScreenHeight() 
99            viewport = fife.Rect(0, 0, width, height)
100            cam.setViewPort(viewport)
101            self.my_cam_id = cam.getId()
102            self.cameras[self.my_cam_id] = cam
103            cam.resetRenderers()
104       
105        self.target_rotation = self.cameras[self.my_cam_id].getRotation()
106
107        self.outline_renderer = fife.InstanceRenderer.\
108                                        getInstance(
109                                                    self.cameras[
110                                                                 self.my_cam_id
111                                                                 ])
112
113        # set the render text
114        rend = fife.FloatingTextRenderer.getInstance(self.cameras[
115                                                                  self.my_cam_id
116                                                                  ])
117        text = self.engine.getGuiManager().\
118                        createFont('fonts/rpgfont.png', 0, \
119                                   Settings.get("FIFE", "FontGlyphs"))
120        rend.changeDefaultFont(text)
121        rend.activateAllLayers(self.map)
122        rend.setEnabled(True)
123       
124        # Activate the grid renderer on all layers
125        rend = self.cameras['map_camera'].getRenderer('GridRenderer')
126        rend.activateAllLayers(self.map)
127         
128        # Activate the grid renderer on all layers
129        rend = fife.CoordinateRenderer.getInstance(self.cameras[
130                                                                  self.my_cam_id
131                                                                  ])
132        rend.setColor(0, 0, 0)
133        rend.addActiveLayer(self.map.getLayer("GroundLayer"))
134
135        # Make World aware that this is now the active map.
136        self.model.active_map = self
137
138    def addPC(self):
139        """Add the player character to the map
140           @return: None"""
141        # Update gamestate.player_character
142        self.model.game_state.player_character.behaviour.onNewMap(self.agent_layer)
143        self.centerCameraOnPlayer()
144
145    def toggleRenderer(self, r_name):
146        """Enable or disable a renderer.
147           @return: None"""
148        renderer = self.cameras[self.my_cam_id].getRenderer(str(r_name))
149        renderer.setEnabled(not renderer.isEnabled())
150
151    def isPaused(self):
152        """Returns wheter the map is currentply paused or not"""
153        # Time multiplier is a float, never do equals on floats
154        return not self.map.getTimeMultiplier() >= 1.0
155   
156    def pause(self, paused):
157        """ Pause/Unpause the game.
158        @return: nothing"""
159        if paused:
160            self.map.setTimeMultiplier(0.0)
161        if not paused and self.isPaused():
162            self.map.setTimeMultiplier(1.0)
163       
164    def togglePause(self):
165        """ Toggle paused state.
166        @return: nothing"""
167        self.pause(not self.isPaused())
168
169    def centerCameraOnPlayer(self):
170        """Center the camera on the player"""
171        camera = self.cameras[self.my_cam_id]
172        player_agent = self.model.game_state.player_character.behaviour.agent
173        camera.setLocation(player_agent.getLocation())
Note: See TracBrowser for help on using the repository browser.