def getDockArea(self): if not self.docked: dockAreas = [] # all top widgets are used for the search if not self.parent: topWidgets = get_manager().allTopHierachyWidgets for t in topWidgets: dockAreas.extend(t.findChildren(__class__=DockArea)) else: # only all childs are used for the search dockAreas = self.parent.findChildren(__class__=DockArea) # reverse order so inner/deeper Areas are preferred dockAreas.reverse() # try to find an intersecting and active DockArea dim = fife.Rect(0, 0, self.width, self.height) dim.x, dim.y = self.getAbsolutePos() for d in dockAreas: if d.real_widget.isActiveDockArea(): ddim = fife.Rect(0, 0, d.width, d.height) ddim.x, ddim.y = d.getAbsolutePos() if dim.intersects(ddim): return d return None else: return self.parent
def __init__(self, session): """ @param session: Session instance """ super(View, self).__init__() self.session = session self.model = horizons.globals.fife.engine.getModel() self.map = self.model.createMap("map") cellgrid = self.model.getCellGrid('square') cellgrid.thisown = 0 cellgrid.setRotation(0) cellgrid.setXScale(1) cellgrid.setYScale(1) cellgrid.setXShift(0) cellgrid.setYShift(0) self.layers = [] for layer_id in xrange(LAYERS.NUM): layer = self.map.createLayer(str(layer_id), cellgrid) if layer_id == LAYERS.OBJECTS: layer.setPathingStrategy(fife.CELL_EDGES_AND_DIAGONALS) layer.setWalkable(True) self.layers.append(layer) self.map.initializeCellCaches() self.map.finalizeCellCaches() # Make sure layer can't change size on layer.createInstance # This is necessary because otherwise ship movement on the map edges would # keep changing the units' layer size. for layer in self.layers: if layer.getCellCache(): layer.getCellCache().setStaticSize(True) rect = fife.Rect(0, 0, horizons.globals.fife.engine_settings.getScreenWidth(), horizons.globals.fife.engine_settings.getScreenHeight()) self.cam = self.map.addCamera("main", self.layers[-1], rect) self.cam.setCellImageDimensions(*VIEW.CELL_IMAGE_DIMENSIONS) self.cam.setRotation(VIEW.ROTATION) self.cam.setTilt(VIEW.TILT) self.cam.setZoom(VIEW.ZOOM_DEFAULT) self.cam.resetRenderers() self.renderer = {} for r in ('InstanceRenderer', 'GridRenderer', 'CellSelectionRenderer', 'BlockingInfoRenderer', 'FloatingTextRenderer', 'QuadTreeRenderer', 'CoordinateRenderer', 'GenericRenderer'): self.renderer[r] = getattr(fife, r).getInstance(self.cam) if hasattr(fife, r) else self.cam.getRenderer(r) self.renderer[r].clearActiveLayers() self.renderer[r].setEnabled(r in ('InstanceRenderer','GenericRenderer')) self.renderer['InstanceRenderer'].activateAllLayers(self.map) self.renderer['GenericRenderer'].addActiveLayer(self.layers[LAYERS.OBJECTS]) self.renderer['GridRenderer'].addActiveLayer(self.layers[LAYERS.GROUND]) #Setup autoscroll horizons.globals.fife.pump.append(self.do_autoscroll) self.time_last_autoscroll = time.time() self._autoscroll = [0, 0] self._autoscroll_keys = [0, 0]
def changeRes2(self): #PyCEGUIOpenGLRenderer.OpenGLRenderer.grabTextures( # PyCEGUI.System.getSingleton().getRenderer()) self.change_res = False old_mode = self.engine.getRenderBackend().getCurrentScreenMode() new_mode = self.engine.getDeviceCaps().getNearestScreenMode( int( self.settings.get("FIFE", "ScreenResolution", "1024x768").split("x")[0]), int( self.settings.get("FIFE", "ScreenResolution", "1024x768").split("x")[1]), self.settings.get("FIFE", "BitsPerPixel", "0"), self.settings.get("FIFE", "RenderBackend", "OpenGL"), self.settings.get("FIFE", "FullScreen", False)) if (old_mode.getWidth() == new_mode.getWidth() and old_mode.getHeight() == new_mode.getHeight() and old_mode.isFullScreen() == new_mode.isFullScreen() and self.engine.getRenderBackend().isVSyncEnabled() == self.settings.get("FIFE", "VSync", True)): return self.engine.getRenderBackend().setVSyncEnabled( self.settings.get("FIFE", "VSync", True)) self.engine.changeScreenMode(new_mode) if not self.view: return self.camera.setViewPort( fife.Rect(0, 0, self.engine.getRenderBackend().getScreenWidth(), self.engine.getRenderBackend().getScreenHeight())) self.camera.refresh()
def _empty(engine): global _inited if not _inited: _init(engine) _inited = True cellgrid = fife.SquareGrid(True) cellgrid.thisown = 0 cellgrid.setRotation(0) cellgrid.setXScale(1) cellgrid.setYScale(1) cellgrid.setXShift(0) cellgrid.setYShift(0) engine.getModel().deleteMaps() map = engine.getModel().createMap("island") layer = map.createLayer('ground', cellgrid) layer.setPathingStrategy(fife.CELL_EDGES_AND_DIAGONALS) view = engine.getView() view.clearCameras() cam = view.addCamera("main", layer, fife.Rect(0, 0, 1024, 768)) cam.setCellImageDimensions(64, 32) cam.setRotation(315.0) cam.setTilt(-60) cam.setZoom(1) return map
def saveSettings(self): engine = self._editor.getEngine() id = self._container.collectData('idBox') if id == '': print 'Please enter a camera id.' return try: map = engine.getModel().getMap( str(self._container.collectData('mapBox'))) except fife.Exception: print 'Cannot find the specified map id.' return try: layer = map.getLayer(str(self._container.collectData('layerBox'))) except fife.Exception: print 'Cannot find the specified layer id.' return try: vals = self._container.collectData('viewBox').split(',') if len(vals) != 4: raise ValueError viewport = fife.Rect(*[int(c) for c in vals]) except ValueError: print 'Please enter 4 comma (,) delimited values for viewport x,y,width,height.' return try: refh = int(self._container.collectData('refhBox')) refw = int(self._container.collectData('refwBox')) except ValueError: print 'Please enter positive integer values for reference width and height.' return try: rot = int(self._container.collectData('rotBox')) tilt = int(self._container.collectData('tiltBox')) except ValueError: print 'Please enter positive integer values for rotation and tilt.' return self._camera = self._editor.getActiveMapView().getCamera() self._camera.setId(str(id)) self._camera.getLocation().setLayer(layer) self._camera.setViewPort(viewport) self._camera.setCellImageDimensions(refw, refh) self._camera.setRotation(rot) self._camera.setTilt(tilt) ztoy = int(self._container.collectData('ztoyNBox')) if ztoy is not 0 and ztoy is not self._camera.getOriginalZToY(): self._camera.setZToY(ztoy) self.toggle()
def _finished(self): id = self._widget.collectData('idBox') if id == '': dialogs.message(message=unicode("Please enter a camera ID."), caption=unicode("Error")) return try: map = self.engine.getModel().getMap(str(self._widget.collectData('mapBox'))) except fife.Exception: dialogs.message(message=unicode("Cannot find the specified map id."), caption=unicode("Error")) return try: layer = map.getLayer(str(self._widget.collectData('layerBox'))) except fife.Exception: dialogs.message(message=unicode("Cannot find the specified layer id."), caption=unicode("Error")) return try: vals = self._widget.collectData('viewBox').split(',') if len(vals) != 4: raise ValueError viewport = fife.Rect(*[int(c) for c in vals]) except ValueError: dialogs.message(message=unicode("Please enter 4 comma (,) delimited values for viewport x,y,width,height."), caption=unicode("Error")) return try: refh = int(self._widget.collectData('refhBox')) refw = int(self._widget.collectData('refwBox')) except ValueError: dialogs.message(message=unicode("Please enter positive integer values for reference width and height."), caption=unicode("Error")) return try: rot = int(self._widget.collectData('rotBox')) tilt = int(self._widget.collectData('tiltBox')) except ValueError: dialogs.message(message=unicode("Please enter positive integer values for rotation and tilt."), caption=unicode("Error")) return cam = map.addCamera(str(id), layer, viewport) cam.setCellImageDimensions(refw, refh) cam.setRotation(rot) cam.setTilt(tilt) renderer = fife.InstanceRenderer.getInstance(cam) renderer.activateAllLayers(map) self._widget.hide() if self.callback: self.callback()
def __init__(self, session, center=(0, 0)): """ @param session: Session instance @param center: center position for the main camera """ super(View, self).__init__() self.session = session self.model = horizons.main.fife.engine.getModel() self.map = self.model.createMap("map") cellgrid = self.model.getCellGrid('square') cellgrid.thisown = 0 cellgrid.setRotation(0) cellgrid.setXScale(1) cellgrid.setYScale(1) cellgrid.setXShift(0) cellgrid.setYShift(0) self.layers = [] for i in xrange(0, LAYERS.NUM): self.layers.append(self.map.createLayer(str(i), cellgrid)) self.layers[i].setPathingStrategy(fife.CELL_EDGES_ONLY) self.cam = self.map.addCamera("main", self.layers[len(self.layers) - 1], \ fife.Rect(0, 0, \ horizons.main.fife.engine_settings.getScreenWidth(), \ horizons.main.fife.engine_settings.getScreenHeight()) \ ) self.cam.setCellImageDimensions(*VIEW.CELL_IMAGE_DIMENSIONS) self.cam.setRotation(VIEW.ROTATION) self.cam.setTilt(VIEW.TILT) self.cam.setZoom(VIEW.ZOOM) self.cam.resetRenderers() self.renderer = {} for r in ('InstanceRenderer', 'GridRenderer', \ 'CellSelectionRenderer', 'BlockingInfoRenderer', 'FloatingTextRenderer', \ 'QuadTreeRenderer', 'CoordinateRenderer', 'GenericRenderer'): self.renderer[r] = getattr(fife, r).getInstance( self.cam) if hasattr(fife, r) else self.cam.getRenderer(r) self.renderer[r].clearActiveLayers() self.renderer[r].setEnabled(r in ('InstanceRenderer', 'GenericRenderer')) self.renderer['InstanceRenderer'].activateAllLayers(self.map) self.renderer['GenericRenderer'].addActiveLayer( self.layers[LAYERS.OBJECTS]) self.renderer['GridRenderer'].addActiveLayer( self.layers[LAYERS.GROUND]) #Setup autoscroll horizons.main.fife.pump.append(self.do_autoscroll) self.time_last_autoscroll = time.time() self._autoscroll = [0, 0] self._autoscroll_keys = [0, 0]
def findPoint(self, event): point = None pos = -1 thickness = self.point_graph.thickness points = self.point_graph.coordinates rec = fife.Rect(event.getX() - thickness, event.getY() - thickness, thickness * 2, thickness * 2) for i, p in enumerate(points): if rec.contains(fife.Point(p.x, p.y)): point = p pos = i break return (point, pos)
def mouseDragged(self, evt): if evt.getButton() == fife.MouseEvent.LEFT and hasattr( self, 'select_begin'): x, y = self.select_begin xx, yy = evt.getX(), evt.getY() do_multi = ((x - xx)**2 + (y - yy)**2) >= 10 # from 3px (3*3 + 1) self.session.view.renderer['GenericRenderer'].removeAll( self.__class__._SELECTION_RECTANGLE_NAME) if do_multi: # draw a rectangle xmin, xmax = min(x, xx), max(x, xx) ymin, ymax = min(y, yy), max(y, yy) a = fife.Point(xmin, ymin) b = fife.Point(xmax, ymin) c = fife.Point(xmax, ymax) d = fife.Point(xmin, ymax) self._draw_rect_line(a, b) self._draw_rect_line(b, c) self._draw_rect_line(d, c) self._draw_rect_line(d, a) area = fife.Rect(xmin, ymin, xmax - xmin, ymax - ymin) else: area = fife.ScreenPoint(xx, yy) instances = self.session.view.cam.getMatchingInstances( area, self.session.view.layers[LAYERS.OBJECTS], False) # False for accurate # get selection components instances = (self.fife_instance_to_uh_instance(i) for i in instances) instances = [i for i in instances if i is not None] # We only consider selectable items when dragging a selection box. instances = self.filter_selectable(instances) # If there is at least one player unit, we don't select any enemies. # This applies to both buildings and ships. if any( (self.is_owned_by_player(instance) for instance in instances)): instances = self.filter_owner(instances) self._update_selection(instances, do_multi) elif evt.getButton() == fife.MouseEvent.RIGHT: pass else: super(SelectionTool, self).mouseDragged(evt) return evt.consume()
def load_image(self, file, actionset, action, rotation): loader = self._get_loader(actionset) entry = loader.get_sets()[actionset][action][int(rotation)][file] # we don't need to load images at this point to query for its parameters # such as width and height because we can get those from json file xpos, ypos, width, height = entry[2:] if horizons.globals.fife.imagemanager.exists(file): img = horizons.globals.fife.imagemanager.get(file) else: img = horizons.globals.fife.imagemanager.create(file) region = fife.Rect(xpos, ypos, width, height) img.useSharedImage(self.atlaslib[entry[1]], region) return img
def resize_layers(self, db): """Resize layers to the size required by the entire map.""" min_x, min_y, max_x, max_y = db("SELECT min(x), min(y), max(x), max(y) FROM ground")[0] min_x -= MAP.PADDING min_y -= MAP.PADDING max_x += MAP.PADDING max_y += MAP.PADDING for layer_id, layer in enumerate(self.layers): if not layer.getCellCache(): continue assert layer_id != LAYERS.WATER, 'Water layer would need special treatment (see previous version)' rect = fife.Rect(min_x, min_y, max_x - min_x + 1, max_y - min_y + 1) layer.getCellCache().setSize(rect)
def resize_layers(self, db): """Resize layers to the size required by the entire map.""" min_x, min_y, max_x, max_y = db("SELECT min(x), min(y), max(x), max(y) FROM ground")[0] if min_x is None: # this happens on the empty maps that are created for the editor min_x, min_y, max_x, max_y = (0, 0, 0, 0) min_x -= db.map_padding min_y -= db.map_padding max_x += db.map_padding max_y += db.map_padding for layer_id, layer in enumerate(self.layers): if not layer.getCellCache(): continue assert layer_id != LAYERS.WATER, 'Water layer would need special treatment (see previous version)' rect = fife.Rect(min_x, min_y, max_x - min_x + 1, max_y - min_y + 1) layer.getCellCache().setSize(rect)
def mouseDragged(self, event): instancerenderer = fife.InstanceRenderer.getInstance( self._test._camera) instancerenderer.removeAllColored() instancerenderer.removeAllOutlines() if event.getButton() == fife.MouseEvent.LEFT and hasattr( self, 'select_begin'): do_multi = ((self.select_begin[0] - event.getX())**2 + (self.select_begin[1] - event.getY())** 2) >= 10 # from 3px (3*3 + 1) genericrenderer = fife.GenericRenderer.getInstance( self._test._camera) genericrenderer.removeAll("selection") if do_multi: # draw a rectangle a = fife.Point(min(self.select_begin[0], event.getX()), \ min(self.select_begin[1], event.getY())) b = fife.Point(max(self.select_begin[0], event.getX()), \ min(self.select_begin[1], event.getY())) c = fife.Point(max(self.select_begin[0], event.getX()), \ max(self.select_begin[1], event.getY())) d = fife.Point(min(self.select_begin[0], event.getX()), \ max(self.select_begin[1], event.getY())) genericrenderer.addLine("selection", \ fife.RendererNode(a), fife.RendererNode(b), 200, 200, 200) genericrenderer.addLine("selection", \ fife.RendererNode(b), fife.RendererNode(c), 200, 200, 200) genericrenderer.addLine("selection", \ fife.RendererNode(d), fife.RendererNode(c), 200, 200, 200) genericrenderer.addLine("selection", \ fife.RendererNode(a), fife.RendererNode(d), 200, 200, 200) instances = self._test._camera.getMatchingInstances(\ fife.Rect(min(self.select_begin[0], event.getX()), \ min(self.select_begin[1], event.getY()), \ abs(event.getX() - self.select_begin[0]), \ abs(event.getY() - self.select_begin[1])) if do_multi else fife.ScreenPoint(event.getX(), event.getY()), self._test._actorlayer, 0) # False for accurate for instance in instances: instancerenderer.addColored(instance, 250, 50, 250) instancerenderer.addOutlined(instance, 255, 255, 0, 2)
def loadResource(self, anim_id): """ @param anim_id: String identifier for the image, eg "as_hunter0+idle+135" """ if not self.inited: self.init() actionset, action, rotation = anim_id.split('+') animationmanager = horizons.globals.fife.animationmanager # if we've loaded that animation before, we can finish early if animationmanager.exists(anim_id): return animationmanager.getPtr(anim_id) ani = animationmanager.create(anim_id) # Set the correct loader based on the actionset loader = self._get_loader(actionset) frame_start, frame_end = 0.0, 0.0 for file in sorted( loader.get_sets()[actionset][action][int(rotation)].keys()): entry = loader.get_sets()[actionset][action][int(rotation)][file] # we don't need to load images at this point to query for its parameters # such as width and height because we can get those from json file xpos, ypos, width, height = entry[2:] if horizons.globals.fife.imagemanager.exists(file): img = horizons.globals.fife.imagemanager.get(file) else: img = horizons.globals.fife.imagemanager.create(file) region = fife.Rect(xpos, ypos, width, height) img.useSharedImage(self.atlaslib[entry[1]], region) img.setYShift(int(img.getWidth() / 4 - img.getHeight() / 2)) frame_end = entry[0] ani.addFrame(img, max(1, int((frame_end - frame_start) * 1000))) frame_start = frame_end # currently unused. would trigger onInstanceActionFrame of # fife.InstanceActionListener instance ani.setActionFrame(-1) return ani
def get_hover_instances(self, where, layers=None): """ Utility method, returns the instances under the cursor @param where: anything supporting getX/getY @param layers: list of layer ids to search for. Default to OBJECTS """ if self.consumed_by_widgets: return [] if layers is None: layers = [LAYERS.OBJECTS] all_instances = [] for layer in layers: x = where.getX() y = where.getY() instances = self.session.view.cam.getMatchingInstances( fife.ScreenPoint(x, y), self.session.view.layers[layer], False) # False for accurate # if no instances found, try again and search within a 8px radius if not instances: selection_radius = 8 radius = fife.Rect(x - selection_radius, y - selection_radius, selection_radius * 2, selection_radius * 2) instances = self.session.view.cam.getMatchingInstances( radius, self.session.view.layers[layer]) all_instances.extend(instances) hover_instances = [] for i in all_instances: id = i.getId() # Check id, can be '' if instance is created and clicked on before # actual game representation class is created (network play) if id == '': continue instance = WorldObject.get_object_by_id(int(id)) hover_instances.append(instance) return hover_instances
def rect_test(self, cursor_x, cursor_y): """ create a rect from ORIGIN to mouse cursor coordinates @type cursor_x: int @param cursor_x: x coordinate of the mouse cursor @type cursor_y: int @param cursor_y: y coordinate of the mouse cursor """ if self._camera is None: return if self._actorlayer is None: return ORIGIN = (0, 0) x, y = ORIGIN layer = self._actorlayer rect = fife.Rect(x, y, cursor_x, cursor_y) instances = self._camera.getMatchingInstances(rect, layer, False) for instance in instances: print instance, instance.getId()
def show(self): """ Sets up the camera to display the map. Size of the camera is equal to the screen size """ _camera = None engine = self._editor.getEngine() for cam in self._map.getCameras(): cam.resetRenderers() cam.setEnabled(False) for cam in self._map.getCameras(): if cam.getLocationRef().getMap().getId() == self._map.getId(): rb = engine.getRenderBackend() cam.setViewPort( fife.Rect(0, 0, rb.getScreenWidth(), rb.getScreenHeight())) cam.setEnabled(True) self._camera = cam break else: raise AttributeError( 'No cameras found associated with this map: ' + self._map.getId())
def mouseDragged(self, evt): if evt.getButton() == fife.MouseEvent.LEFT and hasattr( self, 'select_begin'): do_multi = ((self.select_begin[0] - evt.getX())**2 + (self.select_begin[1] - evt.getY())** 2) >= 10 # ab 3px (3*3 + 1) self.session.view.renderer['GenericRenderer'].removeAll("select") if do_multi: a = fife.Point(min(self.select_begin[0], evt.getX()), \ min(self.select_begin[1], evt.getY())) b = fife.Point(max(self.select_begin[0], evt.getX()), \ min(self.select_begin[1], evt.getY())) c = fife.Point(max(self.select_begin[0], evt.getX()), \ max(self.select_begin[1], evt.getY())) d = fife.Point(min(self.select_begin[0], evt.getX()), \ max(self.select_begin[1], evt.getY())) self.session.view.renderer['GenericRenderer'].addLine("select", \ fife.GenericRendererNode(a), fife.GenericRendererNode(b), 200, 200, 200) self.session.view.renderer['GenericRenderer'].addLine("select", \ fife.GenericRendererNode(b), fife.GenericRendererNode(c), 200, 200, 200) self.session.view.renderer['GenericRenderer'].addLine("select", \ fife.GenericRendererNode(d), fife.GenericRendererNode(c), 200, 200, 200) self.session.view.renderer['GenericRenderer'].addLine("select", \ fife.GenericRendererNode(a), fife.GenericRendererNode(d), 200, 200, 200) selectable = [] instances = self.session.view.cam.getMatchingInstances(\ fife.Rect(min(self.select_begin[0], evt.getX()), \ min(self.select_begin[1], evt.getY()), \ abs(evt.getX() - self.select_begin[0]), \ abs(evt.getY() - self.select_begin[1])) if do_multi else fife.ScreenPoint(evt.getX(), evt.getY()), self.session.view.layers[LAYERS.OBJECTS]) # Only one unit, select anyway if len(instances) == 1: instance = WorldObject.get_object_by_id( int(instances[0].getId())) if instance.is_selectable: selectable.append(instance) else: for i in instances: instance = WorldObject.get_object_by_id(int(i.getId())) if instance.is_selectable and instance.owner == self.session.world.player: selectable.append(instance) if len(selectable) > 1: if do_multi: for instance in selectable[:]: # iterate through copy for safe removal if instance.is_building: selectable.remove(instance) else: selectable = [selectable.pop(0)] if do_multi: selectable = set(self.select_old | frozenset(selectable)) else: selectable = set(self.select_old ^ frozenset(selectable)) for instance in self.session.selected_instances - selectable: instance.deselect() for instance in selectable - self.session.selected_instances: instance.select() self.session.selected_instances = selectable elif (evt.getButton() == fife.MouseEvent.RIGHT): pass else: super(SelectionTool, self).mouseDragged(evt) return evt.consume()
def loadResource(self, location): """ @param location: String with the location. See below for details: Location format: <animation_id>:<command>:<params> (e.g.: "123:shift:left-16, bottom-8) Available commands: - shift: Shift the image using the params left, right, center, middle for x shifting and y-shifting with the params: top, bottom, center, middle. A param looks like this: "param_x(+/-)value, param_y(+/-)value" (e.g.: left-16, bottom+8) - cut: #TODO: complete documentation """ commands = location.split(':') id = commands.pop(0) actionset, action, rotation = id.split('+') commands = zip(commands[0::2], commands[1::2]) ani = fife.Animation.createAnimation() # Set the correct loader based on the actionset loader = self._get_loader(actionset) frame_start, frame_end = 0.0, 0.0 for file in sorted(loader.get_sets()[actionset][action][int(rotation)].iterkeys()): entry = loader.get_sets()[actionset][action][int(rotation)][file] # we don't need to load images at this point to query for its parameters # such as width and height because we can get those from json file xpos, ypos, width, height = entry[2:] if horizons.globals.fife.imagemanager.exists(file): img = horizons.globals.fife.imagemanager.get(file) else: img = horizons.globals.fife.imagemanager.create(file) region = fife.Rect(xpos, ypos, width, height) img.useSharedImage(self.atlaslib[entry[1]], region) for command, arg in commands: if command == 'shift': x, y = arg.split(',') if x.startswith('left'): x = int(x[4:]) + int(width / 2) elif x.startswith('right'): x = int(x[5:]) - int(width / 2) elif x.startswith(('center', 'middle')): x = int(x[6:]) else: x = int(x) if y.startswith('top'): y = int(y[3:]) + int(height / 2) elif y.startswith('bottom'): y = int(y[6:]) - int(height / 2) elif y.startswith(('center', 'middle')): y = int(y[6:]) else: y = int(y) img.setXShift(x) img.setYShift(y) frame_end = entry[0] ani.addFrame(img, max(1, int((float(frame_end) - frame_start)*1000))) frame_start = float(frame_end) ani.setActionFrame(0) return ani
def __init__(self, application): print("* Initializing view...") self.application = application self.camera = self.application.camera self.target_zoom = 1.0 self.camera.setZoom(1.0) self.target_rotation = self.camera.getRotation() self.camera_move_key_up = False self.camera_move_key_down = False self.camera_move_key_left = False self.camera_move_key_right = False self.camera_move_mouse_up = False self.camera_move_mouse_down = False self.camera_move_mouse_left = False self.camera_move_mouse_right = False self.effects = [] self.camera.setViewPort( fife.Rect( 0, 0, self.application.engine.getRenderBackend().getScreenWidth(), self.application.engine.getRenderBackend().getScreenHeight())) self.attachCameraToPlayer() print(" * Enabling renderers...") self.instance_renderer = fife.InstanceRenderer.getInstance(self.camera) self.instance_renderer.addIgnoreLight(["effects"]) self.floating_text_renderer = fife.FloatingTextRenderer.getInstance( self.camera) textfont = get_manager().createFont( "fonts/rpgfont.png", 0, str(application.settings.get("FIFE", "FontGlyphs"))) self.floating_text_renderer.setFont(textfont) self.floating_text_renderer.activateAllLayers(self.application.map) self.floating_text_renderer.setEnabled(True) self.grid_renderer = self.camera.getRenderer("GridRenderer") self.grid_renderer.setEnabled(False) self.grid_renderer.activateAllLayers(self.application.map) self.coordinate_renderer = fife.CoordinateRenderer.getInstance( self.camera) self.coordinate_renderer.setFont(textfont) self.coordinate_renderer.setEnabled(False) self.coordinate_renderer.activateAllLayers(self.application.map) self.cell_renderer = fife.CellRenderer.getInstance(self.camera) self.cell_renderer.clearActiveLayers() self.cell_renderer.addActiveLayer(self.application.maplayer) self.cell_renderer.setEnabled(True) self.cell_renderer.setEnabledBlocking(False) self.cell_renderer.setEnabledFogOfWar(True) self.concimg = self.application.engine.getImageManager().load( "objects/black_cell.png") self.maskimg = self.application.engine.getImageManager().load( "objects/mask_cell.png") self.cell_renderer.setConcealImage(self.concimg) self.cell_renderer.setMaskImage(self.maskimg) self.cell_renderer.setFogOfWarLayer(self.application.maplayer) self.light_renderer = fife.LightRenderer.getInstance(self.camera) self.light_renderer.setEnabled(True) self.light_renderer.clearActiveLayers() self.light_renderer.addActiveLayer(self.application.maplayer) self.layer_change_listener = ViewLayerChangeListener(self) self.application.maplayer.addChangeListener(self.layer_change_listener) print("* View initialized!")
def __init__(self, application): print "* Initializing view..." self.application = application self.camera = self.application.camera self.target_rotation = self.camera.getRotation() self.target_zoom = self.camera.getZoom() self.target_ZToY = self.camera.getZToY() self.camera_move_key_up = False self.camera_move_key_down = False self.camera_move_key_left = False self.camera_move_key_right = False self.camera_move_mouse_up = False self.camera_move_mouse_down = False self.camera_move_mouse_left = False self.camera_move_mouse_right = False self.camera.setViewPort( fife.Rect( 0, 0, self.application.engine.getRenderBackend().getScreenWidth(), self.application.engine.getRenderBackend().getScreenHeight())) print " * Enabling renderers..." self.instance_renderer = fife.InstanceRenderer.getInstance(self.camera) #self.cell_renderer = fife.CellRenderer.getInstance(self.camera) #self.cell_renderer.setEnabled(True) #self.cell_renderer.setEnabledPathVisual(True) #self.cell_renderer.setPathColor(255, 210, 0) #self.cell_renderer.activateAllLayers(self.application.map) self.floating_text_renderer = fife.FloatingTextRenderer.getInstance( self.camera) #print get_manager() textfont = get_manager().createFont( 'fonts/rpgfont.png', 0, str(application.settings.get("FIFE", "FontGlyphs"))) self.floating_text_renderer.setFont(textfont) self.floating_text_renderer.activateAllLayers(self.application.map) self.floating_text_renderer.setBackground(255, 210, 0, 127) self.floating_text_renderer.setBorder(255, 210, 0) self.floating_text_renderer.setEnabled(True) #self.grid_renderer = self.camera.getRenderer('GridRenderer') #self.grid_renderer.setEnabled(True) #self.grid_renderer.activateAllLayers(self.application.map) #self.coordinate_renderer = fife.CoordinateRenderer.getInstance(self.camera) #self.coordinate_renderer.setFont(textfont) #self.coordinate_renderer.setEnabled(True) #self.coordinate_renderer.activateAllLayers(self.application.map) # outline the terrain by cloning instances and manipulating drawing order print " * Generating outlines and mist..." for instance in self.application.maplayer.getInstances(): coordinates = instance.getLocation().getExactLayerCoordinates() if instance.getObject().getId()[:5] == "block": new_instance = self.application.maplayer.createInstance( instance.getObject(), coordinates) new_instance.setCellStackPosition(55) fife.InstanceVisual.create(new_instance).setStackPosition(55) newer_instance = self.application.maplayer.createInstance( instance.getObject(), coordinates) newer_instance.setCellStackPosition(110) fife.InstanceVisual.create(newer_instance).setStackPosition( 110) self.instance_renderer.addOutlined(new_instance, 0, 0, 0, 1, 1, 15, 49, 32, 34) self.instance_renderer.addOutlined(instance, 0, 0, 0, 1, 1, 0, 0, 0, 0) elif instance.getObject().getId() == "water": coordinates.z -= 0.5 new_instance = self.application.maplayer.createInstance( self.application.model.getObject("water_under", "tactics"), coordinates) new_instance.setCellStackPosition(110) coordinates.z -= 0.5 newer_instance = self.application.maplayer.createInstance( self.application.model.getObject("water_under", "tactics"), coordinates) newer_instance.setCellStackPosition(110) instance.setCellStackPosition(110) #self.instance_renderer.addOutlined(new_instance, 0, 0, 0, 1, 1) #self.instance_renderer.addOutlined(instance, 0, 0, 0, 1, 1) # add mist gradient self.instance_renderer.addColored( newer_instance, 0, 0, 0, self.mistIntensity(coordinates.z))
def __init__(self, application): print("* Initializing view...") self.application = application self.camera = self.application.camera self.target_zoom = 1.0 self.camera.setZoom(1.0) self.camera_move_key_up = False self.camera_move_key_down = False self.camera_move_key_left = False self.camera_move_key_right = False self.camera_move_mouse_up = False self.camera_move_mouse_down = False self.camera_move_mouse_left = False self.camera_move_mouse_right = False self.effects = [] #self.tiles = {} self.tiles = [] self.hidden_obstructions = [] self.last_hour = None self.cursor = self.application.cursor self.camera.setViewPort( fife.Rect( 0, 0, self.application.engine.getRenderBackend().getScreenWidth(), self.application.engine.getRenderBackend().getScreenHeight())) print(" * Enabling renderers...") self.instance_renderer = fife.InstanceRenderer.getInstance(self.camera) self.instance_renderer.addIgnoreLight(["effects"]) #self.foo = True self.floating_text_renderer = fife.FloatingTextRenderer.getInstance( self.camera) textfont = get_manager().createFont( "fonts/rpgfont.png", 0, str(application.settings.get("FIFE", "FontGlyphs"))) self.floating_text_renderer.setFont(textfont) self.floating_text_renderer.activateAllLayers(self.application.map) #self.floating_text_renderer.setBackground(210, 210, 100, 63) #self.floating_text_renderer.setBorder(210, 210, 100) self.floating_text_renderer.setEnabled(True) self.grid_renderer = self.camera.getRenderer("GridRenderer") self.grid_renderer.setEnabled(False) self.grid_renderer.activateAllLayers(self.application.map) self.coordinate_renderer = fife.CoordinateRenderer.getInstance( self.camera) self.coordinate_renderer.setFont(textfont) self.coordinate_renderer.setEnabled(False) self.coordinate_renderer.activateAllLayers(self.application.map) self.cell_renderer = fife.CellRenderer.getInstance(self.camera) self.cell_renderer.clearActiveLayers() self.cell_renderer.addActiveLayer(self.application.maplayer) self.cell_renderer.setEnabled(True) self.cell_renderer.setEnabledBlocking(False) self.cell_renderer.setEnabledFogOfWar(False) self.concimg = self.application.engine.getImageManager().load( "objects/Effects/black_cell.png") self.maskimg = self.application.engine.getImageManager().load( "objects/Effects/mask_cell.png") self.cell_renderer.setConcealImage(self.concimg) self.cell_renderer.setMaskImage(self.maskimg) self.cell_renderer.setFogOfWarLayer(self.application.maplayer) #self.cell_renderer.setEnabledPathVisual(True) #self.cell_renderer.setPathColor(255, 210, 0) self.light_renderer = fife.LightRenderer.getInstance(self.camera) self.light_renderer.setEnabled(True) self.light_renderer.clearActiveLayers() self.light_renderer.addActiveLayer(self.application.maplayer) print(" * Customizing looping animations...") self.pingPongAnimations() print(" * Activating plants and animals...") self.randomizeAnimations() self.activateAnimals() if self.application.current_character: if self.application.current_character.visual: self.camera.attach( self.application.current_character.visual.instance) self.application.current_character.visual.instance.setVisitor( True) self.application.current_character.visual.instance.setVisitorRadius( 9) self.layer_change_listener = ViewLayerChangeListener(self) self.application.maplayer.addChangeListener(self.layer_change_listener) print("* View initialized!")
def loadXMLAnimation(engine, filename): f = engine.getVFS().open(filename) f.thisown = 1 imgMgr = engine.getImageManager() tree = ET.parse(f) node = tree.getroot() animation = fife.Animation.createAnimation() common_width = int(node.get('width', 0)) common_height = int(node.get('height', 0)) common_y_offset = int(node.get('y_offset', 0)) common_frame_delay = int(node.get('delay', 0)) common_x_offset = int(node.get('x_offset', 0)) common_y_offset = int(node.get('y_offset', 0)) animation.setActionFrame(int(node.get('action', 0))) frames = node.findall('frame') if not frames: raise InvalidFormat('animation without <frame>s') atlas = node.get('atlas') if atlas: path = filename.split('/') path.pop() path.append(str(atlas)) atlas_file = '/'.join(path) if imgMgr.exists(atlas_file): atlas_img = imgMgr.getPtr(str(atlas_file)) else: atlas_img = imgMgr.create(str(atlas_file)) # parse atlas animation format 2 (e.g. cursor) for frame in frames: source = frame.get('source') if not source: raise InvalidFormat('animation without <frame>s') frame_x_pos = int(frame.get('xpos', 0)) frame_y_pos = int(frame.get('ypos', 0)) frame_x_offset = int(frame.get('x_offset', common_x_offset)) frame_y_offset = int(frame.get('y_offset', common_y_offset)) frame_delay = int(frame.get('delay', common_frame_delay)) frame_width = int(frame.get('width', common_width)) frame_height = int(frame.get('height', common_height)) # xml paths are relative to the directory of the file they're used in. path = filename.split('/') path.pop() path.append(str(source)) frame_file = '/'.join(path) frame_file = atlas, ":", frame_file if imgMgr.exists(str(frame_file)): frame_img = imgMgr.getPtr(str(frame_file)) else: frame_img = imgMgr.create(str(frame_file)) region = fife.Rect(frame_x_pos, frame_y_pos, frame_width, frame_height) frame_img.useSharedImage(atlas_img, region) frame_img.setXShift(frame_x_offset) frame_img.setYShift(frame_y_offset) animation.addFrame(frame_img, frame_delay) else: # parse single images for frame in frames: source = frame.get('source') if not source: raise InvalidFormat('animation without <frame>s') frame_x_offset = int(frame.get('x_offset', common_x_offset)) frame_y_offset = int(frame.get('y_offset', common_y_offset)) frame_delay = int(frame.get('delay', common_frame_delay)) # xml paths are relative to the directory of the file they're used in. path = filename.split('/') path.pop() path.append(str(source)) image_file = '/'.join(path) img = imgMgr.create(image_file) img.setXShift(frame_x_offset) img.setYShift(frame_y_offset) animation.addFrame(img, frame_delay) # animation.thisown = 0 return animation
def parse_cameras(self, mapelt, map): """ create all cameras and activate them FIXME: - should the cameras really be enabled here? IMO that's part of the setup within a client (we just _load_ things here) @type mapelt: object @param mapelt: ElementTree root @type map: object @param map: FIFE map object """ if self.callback: tmplist = mapelt.findall('camera') i = float(0) for camera in mapelt.findall('camera'): _id = camera.get('id') zoom = camera.get('zoom') tilt = camera.get('tilt') rotation = camera.get('rotation') ref_layer_id = camera.get('ref_layer_id') ref_cell_width = camera.get('ref_cell_width') ref_cell_height = camera.get('ref_cell_height') viewport = camera.get('viewport') light_color = camera.get('light_color') if not zoom: zoom = 1 if not tilt: tilt = 0 if not rotation: rotation = 0 if not _id: self._err('Camera declared without an id.') if not ref_layer_id: self._err(''.join([ 'Camera ', str(_id), ' declared with no reference layer.' ])) if not (ref_cell_width and ref_cell_height): self._err(''.join([ 'Camera ', str(_id), ' declared without reference cell dimensions.' ])) try: if viewport: cam = map.addCamera( str(_id), map.getLayer(str(ref_layer_id)), fife.Rect(*[int(c) for c in viewport.split(',')])) else: screen = self.engine.getRenderBackend() cam = map.addCamera( str(_id), map.getLayer(str(ref_layer_id)), fife.Rect(0, 0, screen.getScreenWidth(), screen.getScreenHeight())) renderer = fife.InstanceRenderer.getInstance(cam) renderer.activateAllLayers(map) except fife.Exception as e: print(e.getMessage()) if light_color: cam.setLightingColor( *[float(c) for c in light_color.split(',')]) cam.setCellImageDimensions(int(ref_cell_width), int(ref_cell_height)) cam.setRotation(float(rotation)) cam.setTilt(float(tilt)) cam.setZoom(float(zoom)) renderer = fife.InstanceRenderer.getInstance(cam) renderer.activateAllLayers(map) if self.callback: i += 1 self.callback(self.msg['camera'] % str(_id), float(i / len(tmplist) * 0.25 + 0.75))