source: trunk/game/run.py @ 373

Revision 361, 6.3 KB checked in by orlandov, 10 years ago (diff)

Ticket #104 - Patch by Vaporice and or1andov. Integrate quests into game dialogue and make it possible to persist quest state. fixes[s:trac, t:134]

  • Integrate Vaporice's quest engine implementation
  • Discontinue or1andov's sample dialogue and use Zenbitz's Drunkard
  • Reuse Zenbitz's dialogue functions and callbacks in the game PlayerCharacter? class
  • Whitespace and style tweaks
  • Property svn:eol-style set to native
  • Property svn:executable set to *
Line 
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
16import sys, os, shutil, re
17
18from scripts.common import utils
19# add paths to the swig extensions
20utils.addPaths ('../../engine/swigwrappers/python', '../../engine/extensions')
21
22if not os.path.exists('settings.xml'):
23    shutil.copyfile('settings-dist.xml', 'settings.xml')
24
25import fife_compat, fife, fifelog
26import pychan
27from scripts import world
28from scripts import engine
29from scripts import console
30from scripts.engine import Engine
31from scripts.common import eventlistenerbase
32from basicapplication import ApplicationBase
33from settings import Setting
34
35TDS = 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
42class 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
89class 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
161def main():
162    """Application code starts from here"""
163    app = PARPG()
164    app.run()
165
166if __name__ == '__main__':
167    main()
168
Note: See TracBrowser for help on using the repository browser.