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))
