def startPacking(self, file, outdir=None):
if os.path.isfile(file):
loader = fife.MapLoader(self.model, self.vfs, self.imagemgr,
self.rb)
print 'loading:', file
loader.loadImportFile(file)
# there' only one namespace and one object (single import file)
self.ns = self.model.getNamespaces()[0]
self.object = self.model.getObjects(self.ns)[0]
print 'object', '"' + self.object.getId() + '"'
if len(self.object.getActionIds()) is 0:
print 'object', '"' + self.object.getId(
) + '"', 'doesn\'t have any defined actions, quitting.'
return
if outdir is None:
outdir = os.path.dirname(file) + '-out'
try:
os.mkdir(outdir)
except:
pass
output = os.path.join(outdir, os.path.basename(file))
print 'saving to:', output
self.packActions(self.object, output)
self.model.deleteObjects()
print 'done\n'
else:
raise file + " is not a file!"
def importDir(self, path, filename=""):
if os.path.isdir(os.path.join(path, filename)):
path = os.path.join(path, filename)
path = os.path.normpath(path)
# FIXME: This is necassary for the files to be loaded properly.
# The loader should be fixed to support native (windows)
# path separators.
path = path.replace('\\', '/')
try:
if os.path.isdir(path):
loader = fife.MapLoader(self.engine.getModel(),
self.engine.getVFS(),
self.engine.getImageManager(),
self.engine.getRenderBackend())
loader.loadImportDirectory(path)
else:
raise file + " is not a directory!"
except:
traceback.print_exc(sys.exc_info()[1])
errormsg = u"Importing directory failed:\n"
errormsg += u"File: " + unicode(file) + u"\n"
errormsg += u"Error: " + unicode(sys.exc_info()[1])
ErrorDialog(errormsg)
return None
events.onObjectsImported.send(sender=self)
def openFile(self, path):
""" Opens a file """
parts = path.split(os.sep)
for mapview in self._mapviewlist:
if path == mapview._map.getFilename():
self.getStatusBar().text = u"Map already loaded, omitting map " + parts[-1]
return
events.onOpenMapFile.send(sender=self, path=path)
try:
map = None
fife_loader = fife.MapLoader(self.engine.getModel(), self.engine.getVFS(), self.engine.getImageManager(), self.engine.getRenderBackend())
if self._lighting_mode == 0 and fife_loader.isLoadable(path):
map = fife_loader.load(path)
else:
# TODO: vtchill - once lights are supported by the c++ map loader this can be removed
map = loaders.loadMapFile(path, self.engine, extensions = {'lights': True})
if map:
self.getStatusBar().text = u"Loaded map: " + parts[-1]
return self.newMapView(map)
else:
self.getStatusBar().text = u"Map could not be loaded: " + parts[-1]
return None
except:
traceback.print_exc(sys.exc_info()[1])
errormsg = u"Opening map failed:\n"
errormsg += u"File: "+unicode(path, sys.getfilesystemencoding())+u"\n"
errormsg += u"Error: "+unicode(sys.exc_info()[1])
ErrorDialog(errormsg)
return None
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 __init__(self, settings):
# Call our base class's __init__ function and pass it settings.
# This is where the FIFE engine instance gets created and configured
# (amoungst other things). This includes reading the settings file,
# applying the settings to the engine, initializing PyChan (our GUI
# manager), creating the default application listener (more info on
# this in our later tutorials), and setting up logging. All of
# these things you can do on your own but we provide ApplicationBase
# to make your life easier.
super(Tutorial1Application, self).__init__(settings)
# Save a copy of our settings. This could be useful in the future
# as the Setting module allows you to store your own settins as
# well as FIFE settings.
self._settings = settings
# Initialize an instance of fife.MapLoader which is a built in map
# loader that we provide. We must pass it some internal FIFE objects
# that the loader requires to properly load a map.
self._loader = fife.MapLoader(self.engine.getModel(),
self.engine.getVFS(),
self.engine.getImageManager(),
self.engine.getRenderBackend())
# True if we have a map loaded. False otherwise.
self._mapLoaded = False
def loadLevel(self, filename):
"""
Load a xml map and setup cameras.
"""
self.resetKeys()
self._filename = filename
self.reset()
loader = fife.MapLoader(self._engine.getModel(),
self._engine.getVFS(),
self._engine.getImageManager(),
self._engine.getRenderBackend())
if loader.isLoadable(self._filename):
self._map = loader.load(self._filename)
loader.loadImportFile("objects/projectiles/bullet1/object.xml")
loader.loadImportFile("objects/projectiles/fireball/object.xml")
self._scene = Scene(self, self._engine, self._map.getLayer('objects'), self._soundmanager)
self._scene.initScene(self._map)
self.initCameras()
self._hudwindow.show()
self._gameover.hide()
self._winner.hide()
self._starttime = self._timemanager.getTime()
self._genericrenderer = fife.GenericRenderer.getInstance(self.cameras['main'])
self._genericrenderer.clearActiveLayers()
self._genericrenderer.addActiveLayer(self._map.getLayer('boundingbox'))
self._genericrenderer.setEnabled(True)
def __init__(self, settings):
print("* Initializing application...")
super(Application, self).__init__(settings)
self.settings = settings
self.model = self.engine.getModel()
self.mapLoader = fife.MapLoader(
self.model,
self.engine.getVFS(),
self.engine.getImageManager(),
self.engine.getRenderBackend())
self.objectLoader = fife.ObjectLoader(
self.model,
self.engine.getVFS(),
self.engine.getImageManager(),
self.engine.getAnimationManager())
self.animationLoader = fife.AnimationLoader(
self.engine.getVFS(),
self.engine.getImageManager(),
self.engine.getAnimationManager())
self.map = None
self.view = None
self.change_res = False
self.eventmanager = self.engine.getEventManager()
self.mouselistener = MouseListener(self)
self.keylistener = KeyListener(self)
self.eventmanager.addMouseListenerFront(self.mouselistener)
self.eventmanager.addKeyListenerFront(self.keylistener)
self.soundmanager = self.engine.getSoundManager()
self.soundmanager.init()
self.imagemanager = self.engine.getImageManager()
print("* Application initialized!")
self.gui = GUI(self)
self.real_timeline = RealTimeline()
self.engine.getTimeManager().registerEvent(self.real_timeline)
self.game_speed = settings.get("gameplay", "TimeAcceleration", 1)
print("* Loading objects...")
for import_object in importobjects.import_list:
self.loadObject(import_object)
if self.settings.get("gameplay", "PreloadSprites", True):
self.imagemanager.reloadAll()
print("* Objects loaded!")
self.sounds = {}
self.music = None
self.music_name = ""
if not self.settings.get("FIFE", "PlaySounds"):
self.soundmanager.setVolume(0.0)
self.unloadMap()
self.lastmem = 0
self.last_frame_time = timeit.default_timer()
def __init__(self, engine):
"""Constructor"""
self.__model = engine.getModel()
if 0:
self.__model = fife.Model()
self.__map_loader = fife.MapLoader(engine.getModel(), engine.getVFS(),
engine.getImageManager(),
engine.getRenderBackend())
self.__import_ref_count = {}
self.undo_manager = UndoManager()
def create(self, engine, application):
self._application = application
self._engine = engine
self._running = False
self._loader = fife.MapLoader(self._engine.getModel(),
self._engine.getVFS(),
self._engine.getImageManager(),
self._engine.getRenderBackend())
self._eventmanager = self._engine.getEventManager()
def __init__(self, settings):
# Call our base class's __init__ function and pass it settings.
# This is where the FIFE engine instance gets created and configured
# (amoungst other things). This includes reading the settings file,
# applying the settings to the engine, initializing PyChan (our GUI
# manager), creating the default application listener (more info on
# this in our later tutorials), and setting up logging. All of
# these things you can do on your own but we provide ApplicationBase
# to make your life easier.
super(Tutorial1Application,self).__init__(settings)
# Save a copy of our settings. This could be useful in the future
# as the Setting module allows you to store your own settins as
# well as FIFE settings.
self._settings = settings
# Initialize an instance of fife.MapLoader which is a built in map
# loader that we provide. We must pass it some internal FIFE objects
# that the loader requires to properly load a map.
self._loader = fife.MapLoader(self.engine.getModel(),
self.engine.getVFS(),
self.engine.getImageManager(),
self.engine.getRenderBackend())
# True if we have a map loaded. False otherwise.
self._mapLoaded = False
# Since we want to listen for mouse events lets save a reference to
# the event manager and create our event listener and attach it to
# the manager.
self._eventmanager = self.engine.getEventManager()
self._mouselistener = Tutorial1MouseListener(self)
# Listeners are executed in the order in which they are added.
# Lets ensure this one gets executed first.
self._eventmanager.addMouseListenerFront(self._mouselistener)
# Add the quit botton to the top left of the screen
# First use pychan to load the interface
self._rootpanel = pychan.loadXML('gui/rootpanel.xml')
# Map functions to the buttons on the root panel
self._rootpanel.mapEvents({
'quitButton' : self.onQuitButtonPress,
})
# Finally show the panel so it's visible to the user
self._rootpanel.show()
# Initialize the dialog box to ask the user if they are sure they want
# to quit. The dialog box doesn't get displayed until we call the
# show() function. The first parameter is the function to call when
# the user clicks the "accept" button on the dialog box.
self._quitdialog = QueryDialog(self.quitAccepted, "Attention!", "Are you sure you wan to quit?")
def load(self, filename):
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.initCameras()
self.initAgents()
# Set background color
self.engine.getRenderBackend().setBackgroundColor(80, 80, 255)
def create(self, engine, application):
self._application = application
self._engine = engine
self._running = False
self._loader = fife.MapLoader(self._engine.getModel(),
self._engine.getVFS(),
self._engine.getImageManager(),
self._engine.getRenderBackend())
self._eventmanager = self._engine.getEventManager()
self._imagemanager = self._engine.getImageManager()
self._timemanager = self._engine.getTimeManager()
self._time = self._timemanager.getTime()
self._armor = "clothes"
self._head = "head1"
def __init__(self, gamecontroller):
self._gamecontroller = gamecontroller
self._map = None
self._mapname = None
self._maincameraname = self._gamecontroller.settings.get("RPG", "DefaultCameraName", "camera1")
self._cameras = {}
self._actorlayer = None
self._player = None
self._objectlist = {}
self._objectsettings = None
self._modelsettings = None
self._loader = fife.MapLoader(self._gamecontroller.engine.getModel(),
self._gamecontroller.engine.getVFS(),
self._gamecontroller.engine.getImageManager(),
self._gamecontroller.engine.getRenderBackend())
def activate(self):
"""Activates the map"""
self.__application.world.add_entity_delete_callback(
self.cb_entity_delete)
if not self.is_loaded:
engine = self.__application.engine
loader = fife.MapLoader(engine.getModel(),
engine.getVFS(),
engine.getImageManager(),
engine.getRenderBackend())
if loader.isLoadable(self.__map):
self.__map = loader.load(self.__map)
self.__setup_map_data()
else:
raise RuntimeError("Can't load mapfile %s" % str(self.__map))
self.update_entities()
self.__application.map_loded(self.__map.getId())
else:
self.__application.update_agents(self.__map.getId())
self.camera.setEnabled(True)
def __init__(self, settings):
#self.ar = []
#for i in xrange(512):
# self.ar.append(' ' * memtest.MEGA)
#self.a = ' ' * memtest.MEGA * 1024
#memtest.alloc_max_str()
#memtest.alloc_max_array()
print("* Initializing application...")
super(Application, self).__init__(settings)
self.settings = settings
self.model = self.engine.getModel()
self.mapLoader = fife.MapLoader(self.model, self.engine.getVFS(),
self.engine.getImageManager(),
self.engine.getRenderBackend())
self.objectLoader = fife.ObjectLoader(
self.model, self.engine.getVFS(), self.engine.getImageManager(),
self.engine.getAnimationManager())
# self.atlasLoader = fife.AtlasLoader(self.model,
# self.engine.getVFS(),
# self.engine.getImageManager())
self.map = None
self.world = None
self.view = None
self.change_res = False
self.eventmanager = self.engine.getEventManager()
self.mouselistener = MouseListener(self)
self.keylistener = KeyListener(self)
self.eventmanager.addMouseListenerFront(self.mouselistener)
self.eventmanager.addKeyListenerFront(self.keylistener)
self.soundmanager = self.engine.getSoundManager()
self.soundmanager.init()
self.imagemanager = self.engine.getImageManager()
print("* Application initialized!")
self.gui = GUI(self)
self.real_timeline = RealTimeline()
self.engine.getTimeManager().registerEvent(self.real_timeline)
self.game_speed = 1
#print self.engine.getRenderBackend().isDepthBufferEnabled()
# self.loadAtlas("objects/nature.xml")
print("* Loading objects...")
for import_object in importobjects.import_list:
self.loadObject(import_object)
if self.settings.get("gameplay", "PreloadSprites", True):
self.imagemanager.reloadAll()
print("* Objects loaded!")
self.sounds = {}
self.music = None
self.music_name = ""
#self.music = self.soundmanager.createSoundEmitter("music/SFT-Two Mapple Inn.ogg")
# self.sound_attack = self.soundmanager.createSoundEmitter("sfx/attack-1.ogg")
#self.music.looping = True
if not self.settings.get("FIFE", "PlaySounds"):
self.soundmanager.setVolume(0.0)
#self.music.play()
self.cursor = self.imagemanager.load("gui/cursors/Mousecursor01.png")
self.cursor.setXShift(-4)
#self.imagemanager.free("gui/cursors/Mousecursor01.png")
#self.imagemanager.reload("gui/cursors/Mousecursor01.png")
self.map_cursor = self.imagemanager.load(
"gui/cursors/Mousecursor02.png")
self.map_cursor.setXShift(-29)
self.map_cursor.setYShift(-29)
#self.null_image = self.imagemanager.loadBlank(1, 1)
#self.engine.getCursor().set(self.null_image)
#self.engine.getCursor().setDrag(self.cursor, -4, 0)
self.engine.getCursor().set(self.cursor)
self.unloadMap()
self.lastmem = 0
def __init__(self, settings):
print "* Initializing application..."
super(TacticsApplication, self).__init__(settings)
self.settings = settings
self.model = self.engine.getModel()
self.mapLoader = fife.MapLoader(self.model, self.engine.getVFS(),
self.engine.getImageManager(),
self.engine.getRenderBackend())
self.objectLoader = fife.ObjectLoader(
self.model, self.engine.getVFS(), self.engine.getImageManager(),
self.engine.getAnimationManager())
self.atlasLoader = fife.AtlasLoader(self.model, self.engine.getVFS(),
self.engine.getImageManager(),
self.engine.getAnimationManager())
self.map = None
self.view = None
self.eventmanager = self.engine.getEventManager()
self.mouselistener = TacticsMouseListener(self)
self.keylistener = TacticsKeyListener(self)
self.eventmanager.addMouseListenerFront(self.mouselistener)
self.eventmanager.addKeyListenerFront(self.keylistener)
self.soundmanager = SoundManager(self.engine)
self.fifesoundmanager = self.engine.getSoundManager()
print "* Application initialized!"
self.combat_actions = CombatActions()
self.gui = TacticsGUI(self)
self.real_timeline = RealTimeline()
self.engine.getTimeManager().registerEvent(self.real_timeline)
self.pather = TacticsPather(self)
self.engine.getTimeManager().registerEvent(self.pather)
self.loadObject("objects/tile.xml")
self.loadObject("objects/boy/object.xml")
self.loadObject("objects/dot_red.xml")
self.loadObject("objects/shadow.xml")
self.loadObject("objects/effects/fire.xml")
self.loadObject("objects/effects/explosion.xml")
self.loadObject("objects/effects/freeze.xml")
self.loadObject("objects/projectiles/stone.xml")
self.loadObject("objects/projectiles/fireball.xml")
self.loadObject("objects/projectiles/tarball.xml")
self.loadAtlas("objects/nature.xml")
self.loadObject("objects/caltrops.xml")
self.loadObject("objects/tar.xml")
self.loadObject("objects/ice.xml")
self.loadObject("objects/water_under.xml")
self.loadObject("objects/water.xml")
self.loadObject("objects/block_gray.xml")
self.loadObject("objects/block_grass.xml")
self.music = self.soundmanager.createSoundEmitter("music/music1.ogg")
self.sound_attack = self.soundmanager.createSoundEmitter(
"sfx/attack-1.ogg")
self.sound_fire = self.soundmanager.createSoundEmitter(
"sfx/fire-1.ogg")
self.music.looping = True
if not self.settings.get("FIFE", "PlaySounds"):
self.fifesoundmanager.setVolume(0.0)
self.music.play()
self.unloadMap()
