1 | #!/usr/bin/env python |
---|
2 | |
---|
3 | # This program is free software: you can redistribute it and/or modify |
---|
4 | # it under the terms of the GNU General Public License as published by |
---|
5 | # the Free Software Foundation, either version 3 of the License, or |
---|
6 | # (at your option) any later version. |
---|
7 | |
---|
8 | # This program is distributed in the hope that it will be useful, |
---|
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
11 | # GNU General Public License for more details. |
---|
12 | |
---|
13 | # You should have received a copy of the GNU General Public License |
---|
14 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
---|
15 | |
---|
16 | import sys, os, shutil, re |
---|
17 | |
---|
18 | from scripts.common import utils |
---|
19 | # add paths to the swig extensions |
---|
20 | utils.addPaths ('../../engine/swigwrappers/python', '../../engine/extensions') |
---|
21 | |
---|
22 | if not os.path.exists('settings.xml'): |
---|
23 | shutil.copyfile('settings-dist.xml', 'settings.xml') |
---|
24 | |
---|
25 | import fife_compat, fife, fifelog |
---|
26 | import pychan |
---|
27 | from scripts import world |
---|
28 | from scripts import engine |
---|
29 | from scripts import console |
---|
30 | from scripts.engine import Engine |
---|
31 | from scripts.common import eventlistenerbase |
---|
32 | from basicapplication import ApplicationBase |
---|
33 | from settings import Setting |
---|
34 | |
---|
35 | TDS = Setting() |
---|
36 | |
---|
37 | """This folder holds the main meta-data for PARPG. This file should be |
---|
38 | minimal, since folding code into the controller with MVC is usually bad |
---|
39 | All game and logic and data is held held and referenced in |
---|
40 | /scripts/engine.py. All fife stuff goes in /scripts/world.py""" |
---|
41 | |
---|
42 | class ApplicationListener(eventlistenerbase.EventListenerBase): |
---|
43 | def __init__(self, engine, world, model): |
---|
44 | """Initialise the instance. |
---|
45 | @type engine: engine.Engine |
---|
46 | @param engine: ??? |
---|
47 | @type world: world.World |
---|
48 | @param world: ??? |
---|
49 | @type model: engine.Engine |
---|
50 | @param model: an instance of PARPG's engine""" |
---|
51 | super(ApplicationListener, self).__init__(engine, |
---|
52 | reg_keys=True,reg_cmd=True, |
---|
53 | reg_mouse=False, |
---|
54 | reg_console=True, |
---|
55 | reg_widget=True) |
---|
56 | self.engine = engine |
---|
57 | self.world = world |
---|
58 | self.model = model |
---|
59 | engine.getEventManager().setNonConsumableKeys([fife.Key.ESCAPE,]) |
---|
60 | self.quit = False |
---|
61 | self.aboutWindow = None |
---|
62 | self.console=console.Console(self) |
---|
63 | |
---|
64 | def quitGame(self): |
---|
65 | """Forces a quit game on next cycle. |
---|
66 | @return: None""" |
---|
67 | self.quit = True |
---|
68 | |
---|
69 | def onConsoleCommand(self, command): |
---|
70 | """ |
---|
71 | Called on every console comand, delegates calls to the a console |
---|
72 | object, implementing the callbacks |
---|
73 | @type command: string |
---|
74 | @param command: the command to run |
---|
75 | @return: result |
---|
76 | """ |
---|
77 | |
---|
78 | return self.console.handleConsoleCommand(command) |
---|
79 | |
---|
80 | def onCommand(self, command): |
---|
81 | """Enables the game to be closed via the 'X' button on the window frame |
---|
82 | @type command: fife.Command |
---|
83 | @param command: The command to read. |
---|
84 | @return: None""" |
---|
85 | if(command.getCommandType() == fife.CMD_QUIT_GAME): |
---|
86 | self.quit = True |
---|
87 | command.consume() |
---|
88 | |
---|
89 | class PARPG(ApplicationBase): |
---|
90 | """Main Application class |
---|
91 | We use an MVC data model. |
---|
92 | self.world is our view,self.engine is our model |
---|
93 | This file is the minimal controller""" |
---|
94 | def __init__(self): |
---|
95 | """Initialise the instance. |
---|
96 | @return: None""" |
---|
97 | super(PARPG,self).__init__() |
---|
98 | self.world = world.World(self.engine) |
---|
99 | self.model = engine.Engine(self.world) |
---|
100 | self.world.data = self.model |
---|
101 | self.world.initHud() |
---|
102 | self.listener = ApplicationListener(self.engine,self.world,self.model) |
---|
103 | self.world.quitFunction = self.listener.quitGame |
---|
104 | self.model.loadMap("main-map", str(TDS.readSetting("MapFile"))) |
---|
105 | pychan.init(self.engine, debug = True) |
---|
106 | |
---|
107 | def loadSettings(self): |
---|
108 | """Load the settings from a python file and load them into the engine. |
---|
109 | Called in the ApplicationBase constructor. |
---|
110 | @return: None""" |
---|
111 | import settings |
---|
112 | self.settings = settings |
---|
113 | e_set = self.engine.getSettings() |
---|
114 | e_set.setDefaultFontGlyphs(str(TDS.readSetting("FontGlyphs", |
---|
115 | strip=False))) |
---|
116 | e_set.setDefaultFontPath(str(TDS.readSetting("Font"))) |
---|
117 | e_set.setDefaultFontSize(int(TDS.readSetting("FontSize", default=12))) |
---|
118 | e_set.setBitsPerPixel(int(TDS.readSetting("BitsPerPixel"))) |
---|
119 | e_set.setInitialVolume(float(TDS.readSetting("InitialVolume"))) |
---|
120 | e_set.setSDLRemoveFakeAlpha(int(TDS.readSetting("SDLRemoveFakeAlpha"))) |
---|
121 | e_set.setScreenWidth(int(TDS.readSetting("ScreenWidth"))) |
---|
122 | e_set.setScreenHeight(int(TDS.readSetting("ScreenHeight"))) |
---|
123 | e_set.setRenderBackend(str(TDS.readSetting("RenderBackend"))) |
---|
124 | e_set.setFullScreen(int(TDS.readSetting("FullScreen"))) |
---|
125 | try: |
---|
126 | e_set.setWindowTitle(str(TDS.readSetting("WindowTitle"))) |
---|
127 | e_set.setWindowIcon(str(TDS.readSetting("WindowIcon"))) |
---|
128 | except: |
---|
129 | pass |
---|
130 | try: |
---|
131 | e_set.setImageChunkingSize(int(TDS.readSetting("ImageChunkSize"))) |
---|
132 | except: |
---|
133 | pass |
---|
134 | |
---|
135 | def initLogging(self): |
---|
136 | """Initialize the LogManager. |
---|
137 | @return: None""" |
---|
138 | LogModules = TDS.readSetting("LogModules",type='list') |
---|
139 | self.log = fifelog.LogManager(self.engine, |
---|
140 | int(TDS.readSetting("LogToPrompt")), |
---|
141 | int(TDS.readSetting("LogToFile"))) |
---|
142 | if(LogModules): |
---|
143 | self.log.setVisibleModules(*LogModules) |
---|
144 | |
---|
145 | def createListener(self): |
---|
146 | """@return: None""" |
---|
147 | # already created in constructor |
---|
148 | # but if we don't put one here, Fife gets all fussy :-) |
---|
149 | pass |
---|
150 | |
---|
151 | def _pump(self): |
---|
152 | """Main game loop. |
---|
153 | There are in fact 2 main loops, this one and the one in World. |
---|
154 | @return: None""" |
---|
155 | if self.listener.quit: |
---|
156 | self.breakRequested = True |
---|
157 | else: |
---|
158 | self.model.pump() |
---|
159 | self.world.pump() |
---|
160 | |
---|
161 | def main(): |
---|
162 | """Application code starts from here""" |
---|
163 | app = PARPG() |
---|
164 | app.run() |
---|
165 | |
---|
166 | if __name__ == '__main__': |
---|
167 | main() |
---|
168 | |
---|