def get_bound_rect(self):
origin_enum, align_x, align_y = self.sprite.get_alignment()
align_x = -align_x
origin = Origin.calc_origin(
origin_enum, Size(self.sprite.width, self.sprite.height))
return Rect(
Point(self.pos) - origin - Point(align_x, align_y),
Size(self.sprite.width, self.sprite.height))
def wheelEvent(self, event):
num_degrees = event.angleDelta() / 8
num_steps = int(num_degrees.manhattanLength() / 15)
for _ in range(num_steps):
if num_degrees.x() > 0 or num_degrees.y() > 0:
self.comp.zoom_in(Point.from_qt(event.pos()))
else:
self.comp.zoom_out(Point.from_qt(event.pos()))
def __init__(self):
super().__init__()
TilePaintTool.current = self
self.last_draw = Point(-1, -1)
self.current_tile = Point(0, 0)
self.command = None
self.is_active = False
def draw(self, gc):
gc.fill_rect(Rect(Point(self.pos) - Point(16, 16), Size(32, 32)),
Color(200, 255, 200))
if self.next_node:
gc.draw_line(int(self.pos.x), int(self.pos.y),
int((self.pos.x + self.next_node.pos.x) / 2),
int((self.pos.y + self.next_node.pos.y) / 2),
Color(255, 255, 0))
gc.draw_line(int((self.pos.x + self.next_node.pos.x) / 2),
int((self.pos.y + self.next_node.pos.y) / 2),
int(self.next_node.pos.x), int(self.next_node.pos.y),
Color(255, 0, 0))
def on_mouse_up(self, event):
tilemap = ToolContext.current.tilemap_layer
if tilemap and not tilemap.hidden:
EditorMapComponent.current.get_workspace().get_map().modify()
parent = EditorMapComponent.current
self.current_tile = tilemap.world2tile(
parent.screen2world(event.mouse_pos))
if self.is_active:
self.release_mouse()
self.is_active = False
if ((event.mod & InputEvent.MOD_SHIFT) or
((self.current_tile.x %
ToolContext.current.tile_brush.width) ==
(self.last_draw.x % ToolContext.current.tile_brush.width)
and (self.current_tile.y %
ToolContext.current.tile_brush.height
== (self.last_draw.y %
ToolContext.current.tile_brush.height)))):
self.command.add_point(self.current_tile)
Workspace.current.get_map().execute(self.command)
self.command = None
tilemap.draw_tile_brush(ToolContext.current.tile_brush,
self.current_tile)
self.last_draw = Point(-1, -1)
def new_from_size(self, name, width, height):
self.name = name
self.music = ""
self.gravity = 10.0
self.width = width
self.height = height
self.tilemaps.append(SuperTuxTileMap.from_size(self.width, self.height, "background", -100, False))
self.tilemaps.append(SuperTuxTileMap.from_size(self.width, self.height, "interactive", 0, True))
self.tilemaps.append(SuperTuxTileMap.from_size(self.width, self.height, "foreground", 100, False))
self.object_layer = ObjectLayer()
self.editormap = EditorMap()
# self.editormap.set_background_color(Color(255, 255, 255))
for tilemap in self.tilemaps:
# self.editormap.add_layer(tilemap.tilemap_layer)
self.object_layer.add_object(ObjMapTilemapObject(tilemap.tilemap_layer, tilemap))
spawn = SpawnPoint()
spawn.properties[0].value = "main"
spawn_x = 5 if self.width > 5 else 0
spawn_y = self.height * 3 / 4
spawn.objmap_object.pos = Point(spawn_x * 32, spawn_y * 32)
self.object_layer.add_object(spawn.objmap_object)
self.camera = Camera()
self.object_layer.add_object(self.camera.objmap_object)
self.editormap.add_layer(self.object_layer)
# self.editormap.add_layer(self.sketch)
self.editormap.metadata = self
return self
def from_qt(event):
result = InputEvent()
result.mouse_pos = Point(event.x(), event.y())
if event.button() == 0:
result.kind = InputEvent.MOUSE_NO_BUTTON
elif event.button() == Qt.LeftButton:
result.kind = InputEvent.MOUSE_LEFT
elif event.button() == Qt.MidButton:
result.kind = InputEvent.MOUSE_MIDDLE
elif event.button() == Qt.RightButton:
result.kind = InputEvent.MOUSE_RIGHT
else:
logging.debug("unknown mouse button: " + str(event.button()))
if event.modifiers() & Qt.ControlModifier:
result.mod |= InputEvent.MOD_CTRL
if event.modifiers() & Qt.AltModifier:
result.mod |= InputEvent.MOD_ALT
if event.modifiers() & Qt.ShiftModifier:
result.mod |= InputEvent.MOD_SHIFT
return result
def insert_path_node(self, x, y):
logging.info("Insert path Node")
m = self.workspace.get_map().metadata
pathnode = ObjMapPathNode(self.editor_map.screen2world(Point(x, y)),
"PathNode")
pathnode.metadata = PathNode(pathnode)
m.objects.add_object(pathnode)
def __init__(self):
super().__init__()
self.scrolling = False
self.click_pos = Point(0, 0)
self.old_trans_offset = Pointf(0, 0)
self.layer = None
def from_sexpr(data):
# Load position from path, node and then x, ys
x = 0
y = 0
path = get_value_from_tree(["path"], data, None)
if path:
node = get_value_from_tree(["node"], path, None)
if node:
x = get_value_from_tree(["x", "_"], node, None)
y = get_value_from_tree(["y", "_"], node, None)
name = get_value_from_tree(["name", "_"], data, "")
z_pos = get_value_from_tree(["z-pos", "_"], data, 0)
solid = get_value_from_tree(["solid", "_"], data, False)
result = SuperTuxTileMap(z_pos, solid)
width = get_value_from_tree(["width", "_"], data, 20)
height = get_value_from_tree(["height", "_"], data, 15)
result.draw_target = get_value_from_tree(["draw-target", "_"], data,
"")
result.speed = get_value_from_tree(["speed", "_"], data, 1.0)
result.speed_y = get_value_from_tree(["speed-y", "_"], data, 1.0)
result.alpha = get_value_from_tree(["alpha", "_"], data, 1.0)
result.tilemap_layer = TilemapLayer(SuperTuxTileset.current, width,
height)
result.tilemap_layer.set_data(get_value_from_tree(["tiles"], data, []))
result.tilemap_layer.metadata = result
result.pos = Point(x, y)
result.tilemap_layer.name = name
return result
def make_rect_object(metadata, color=None):
if color is None:
color = Colorf(0, 0, 1.0, 0.5)
pos = Point(0, 0)
size = Size(64, 64)
obj = ObjMapRectObject(Rect(pos, size), color, metadata)
return obj
def __init__(self, pixelbuffer, filename="<unknown-source>"):
self.pixelbuffer = pixelbuffer
self.filename = filename
self.origin = Origin.top_left
self.pos = Point(0, 0)
self.scale = (1.0, 1.0)
def find_closed_layer(self, pos):
layer = None
parent = Workspace.current.get_map()
for i in range(0, parent.get_layer_count()):
if parent.get_layer(i).get_bounding_rect().is_inside(Point(pos)):
layer = parent.get_layer(i)
return layer
def __init__(self, viewport):
super().__init__()
self.viewport = viewport
self.index = 0
self.has_focus = False
self.mouse_over_tile = -1
self.region_select = False
self.current_pos = Point()
self.region_select_start = Point()
self.mouse_pos = Point()
self.scale = 1.0
self.tileset = Tileset(32)
self.tiles = []
self.setMouseTracking(True)
def get_mouse_tile_pos(self, mouse_pos):
x = int(mouse_pos.x / self.cell_size)
y = int(mouse_pos.y / self.cell_size)
if x >= self.columns:
x = self.columns - 1
return Point(x, y)
def test_gameobj_factory_create_gameobj_at(self):
for identifier, (_, _) in supertux_gameobj_factory.objects.items():
try:
obj = supertux_gameobj_factory.create_gameobj_at(
identifier, Point(0, 0))
except Exception:
print("Exception received: %r %r" % (identifier, obj))
raise
def mouseMoveEvent(self, event):
workspace = self.comp.get_workspace()
ev = InputEvent.from_qt(event)
workspace.mouse_move(ev)
self.repaint()
pos = self.comp.screen2world(Point.from_qt(event.pos()))
self.sig_mouse_move(pos)
def __init__(self, width, height):
super().__init__()
self.strokes = []
self.pixelbuffer = PixelBuffer(width, height)
self.surface = None
self.canvas = Canvas()
self.last_pos = Point()
self.surface = None
def __init__(self, z_pos=0, solid=False):
self.solid = solid
self.draw_target = ""
self.z_pos = z_pos
self.speed = 1.0
self.speed_y = 1.0
self.alpha = 1.0
self.pos = Point(0, 0)
self.tilemap_layer = None
def on_mouse_move(self, event):
if self.active:
gc = EditorMapComponent.current.get_gc_state()
zoom_pos = Point(gc.width / 2, gc.height / 2)
factor = (event.mouse_pos.y - self.click_pos.y) / 20.0
if factor > 0:
gc.set_zoom(self.old_zoom * pow(1.25, factor), zoom_pos)
elif factor < 0:
gc.set_zoom(self.old_zoom / pow(1.25, -factor), zoom_pos)
else:
gc.set_zoom(self.old_zoom, zoom_pos)
def draw(self, gc):
tilemap = ToolContext.current.tilemap_layer
if not tilemap:
return
tile_size = tilemap.get_tileset().get_tile_size()
# Draw the brush:
for y in range(0, ToolContext.current.tile_brush.height):
for x in range(0, ToolContext.current.tile_brush.width):
tile = tilemap.get_tileset().create(
ToolContext.current.tile_brush.at(x, y))
if tile:
sprite = tile.get_sprite()
sprite.set_alpha(0.5)
sprite.draw((self.current_tile.x + x) * tile_size,
(self.current_tile.y + y) * tile_size, gc)
gc.fill_rect(
Rect(
Point((self.current_tile.x + x) * tile_size,
(self.current_tile.y + y) * tile_size),
Size(tile_size, tile_size)),
Color(255, 255, 255, 100))
elif ToolContext.current.tile_brush.is_opaque():
gc.fill_rect(
Rect(
Point((self.current_tile.x + x) * tile_size,
(self.current_tile.y + y) * tile_size),
Size(tile_size, tile_size)),
Color(255, 255, 255, 100))
else:
gc.fill_rect(
Rect(
Point((self.current_tile.x + x) * tile_size,
(self.current_tile.y + y) * tile_size),
Size(tile_size, tile_size)),
Color(255, 255, 255, 50))
def calc_origin(origin, size):
if origin == Origin.top_left:
return Point(0, 0)
elif origin == Origin.top_center:
return Point(size.width / 2, 0)
elif origin == Origin.top_right:
return Point(size.width, 0)
elif origin == Origin.center_left:
return Point(0, size.height / 2)
elif origin == Origin.center:
return Point(size.width / 2, size.height / 2)
elif origin == Origin.center_right:
return Point(size.width, size.height / 2)
elif origin == Origin.bottom_left:
return Point(0, size.height)
elif origin == Origin.bottom_center:
return Point(size.width / 2, size.height)
elif origin == Origin.bottom_right:
return Point(size.width, size.height)
def __init__(self, tilemap_layer, brush):
super().__init__()
self.points = []
self.tilemap = tilemap_layer
self.brush = brush
# Copy of the field used to generate undo informations */
self.undo_field = self.tilemap.field.copy()
self.pos = Point(0, 0)
self.redo_brush = None
self.undo_brush = None
def register_keyboard_shortcuts(self):
self.editor_map.sig_on_key("f1").connect(
lambda x, y: self.gui_toggle_minimap())
self.editor_map.sig_on_key("m").connect(
lambda x, y: self.gui_toggle_minimap())
self.editor_map.sig_on_key("g").connect(
lambda x, y: self.gui_toggle_grid())
self.editor_map.sig_on_key("+").connect(
lambda x, y: self.editor_map.zoom_in(Point(x, y)))
self.editor_map.sig_on_key("-").connect(
lambda x, y: self.editor_map.zoom_out(Point(x, y)))
self.editor_map.sig_on_key("Enter").connect(
lambda x, y: self.gui_set_zoom(1.0))
self.editor_map.sig_on_key("i").connect(
lambda x, y: self.insert_path_node(x, y))
self.editor_map.sig_on_key("c").connect(
lambda x, y: self.connect_path_nodes())
self.editor_map.sig_on_key(
"7").connect(lambda x, y: self.workspace.get_map().metadata.parent.
activate_sector("main", self.workspace))
self.editor_map.sig_on_key(
"8").connect(lambda x, y: self.workspace.get_map().metadata.parent.
activate_sector("another_world", self.workspace))
self.editor_map.sig_on_key("p").connect(
lambda x, y: self.gui_show_object_properties())
def on_a_key(x, y):
pos = self.editor_map.screen2world(Point(x, y))
rectobj = ObjMapRectObject(Rect(pos, Size(128, 64)),
Color(0, 255, 255, 155), None)
self.workspace.get_map().metadata.objects.add_object(rectobj)
self.editor_map.sig_on_key("a").connect(on_a_key)
def mouseMoveEvent(self, event):
self.mouse_pos = Point.from_qt(event.pos())
cell_w = self.width() / self.get_columns()
x = int(event.x() // cell_w)
y = int(event.y() // self.cell_height)
self.mouse_over_tile = y * self.get_columns() + x
if self.mouse_over_tile < 0 or self.mouse_over_tile >= len(self.brushes):
self.mouse_over_tile = -1
if self.mouse_over_tile > -1:
self.setToolTip(self.brushes[self.mouse_over_tile].get_data())
self.repaint()
def paintEvent(self, event):
painter = QPainter(self)
gc = GraphicContext(painter)
brush = ToolContext.current.tile_brush
start_row = event.rect().top() // self.cell_size
end_row = (event.rect().bottom() + self.cell_size - 1) // self.cell_size
end_index = min(end_row * self.columns, len(self.tiles))
# Draw tiles
for i in range(start_row * self.columns, end_index):
x = i % self.columns
y = i // self.columns
tile = self.tileset.create(self.tiles[i])
rect = Rect(Point(int(x * self.cell_size),
int(y * self.cell_size)),
Size(self.cell_size,
self.cell_size))
if tile:
sprite = tile.get_sprite()
sprite.set_scale(self.scale, self.scale)
sprite.draw(int(x * self.cell_size),
int(y * self.cell_size), gc)
# Use grid in the tileselector
gc.draw_rect(rect, Color(0, 0, 0, 128))
# mark the currently selected tile
if brush.width == 1 and brush.height == 1 and brush.at(0, 0) == self.tiles[i]:
gc.fill_rect(rect, Color(0, 0, 255, 100))
elif self.mouse_over_tile == i and self.has_focus:
gc.fill_rect(rect, Color(0, 0, 255, 20))
# draw rectangle selection
if self.region_select:
rect = self.get_selection()
rect.top *= self.cell_size
rect.bottom *= self.cell_size
rect.left *= self.cell_size
rect.right *= self.cell_size
gc.fill_rect(rect, Color(0, 0, 255, 100))
def test_point(self):
p = Point(11, 17)
self.assertEqual(p.x, 11)
self.assertEqual(p.y, 17)
p = 3 * p
p = p * 4
p *= 5
self.assertEqual(p.x, 660)
self.assertEqual(p.y, 1020)
p = Point(0, 3) + p
p = p + Point(4, 0)
p += Point(1, 2)
self.assertEqual(p.x, 665)
self.assertEqual(p.y, 1025)
self.assertEqual(Point(11, 17), Point(11, 17))
p2 = p.copy()
self.assertEqual(p, p2)
p2.x += 2
p2.y += 3
self.assertNotEqual(p, p2)
def __init__(self):
super().__init__()
self.objmap_object = ObjMapObject(Point(), self)
self.objmap_object.to_draw = False
self.signal_connect()
self.properties = [
EnumProperty("Mode",
"mode",
default=0,
optional=False,
values=self.values),
BoolProperty("Backscrollling",
"backscrolling",
optional=True,
default=True),
PathProperty("Path", "path")
]
def write(self, writer, obj):
tilemap_position = Point(obj.pos.x // 32, obj.pos.y // 32)
writer.write_inline_point(tilemap_position)
def draw(self, stroke, gc):
if DrawerProperties.current.get_brush().is_null(
) or stroke.get_dab_count() == 0:
return
dabs = stroke.get_interpolated_dabs(
DrawerProperties.current.get_spacing() *
DrawerProperties.current.get_size(),
DrawerProperties.current.get_spacing() *
DrawerProperties.current.get_size())
for i, dab in enumerate(self.dabs):
sprite = DrawerProperties.current.get_brush().get_sprite()
color = DrawerProperties.current.get_color()
sprite.set_color(color)
sprite.set_alpha((color.get_alpha() / 255.0) * dab.pressure)
sprite.set_scale(
DrawerProperties.current.get_size() * dab.pressure,
DrawerProperties.current.get_size() * dab.pressure)
if gc is not None:
# DO Multipass:
# 1: GL_ZERO, GL_DST_ALPHA
# 2: GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA
# brush.set_blend_func_separate(BlendFunc.zero, BlendFunc.dst_alpha,
# BlendFunc.zero, BlendFunc.one)
# brush.draw(dab.pos.x, dab.pos.y, gc)
if self.mode == SpriteStrokeDrawer.DM_NORMAL:
sprite.set_blend_func_separate(
BlendFunc.src_alpha, BlendFunc.one_minus_src_alpha,
BlendFunc.one, BlendFunc.one_minus_src_alpha)
sprite.draw(dab.pos.x, dab.pos.y, gc.gc)
elif self.mode == SpriteStrokeDrawer.DM_ADDITION:
sprite.set_blend_func_separate(BlendFunc.src_alpha,
BlendFunc.one,
BlendFunc.zero,
BlendFunc.one)
# BlendFunc.one, BlendFunc.one_minus_src_alpha)
sprite.draw(dab.pos.x, dab.pos.y, gc.gc)
elif self.mode == SpriteStrokeDrawer.DM_ERASE:
sprite.set_blend_func(BlendFunc.zero,
BlendFunc.one_minus_src_alpha)
sprite.draw(dab.pos.x, dab.pos.y, gc.gc)
elif self.mode == SpriteStrokeDrawer.DM_SMUDGE:
if dab != dabs[0]:
canvas = BitmapLayer.current.get_canvas()
buffer = canvas.get_pixeldata(
Rect(
Point(
int(self.dabs[i - 1].pos.x) -
sprite.width / 2,
int(self.dabs[i - 1].pos.y) -
sprite.height / 2),
Size(sprite.width, sprite.height)))
surface = Surface(buffer)
# surface.set_blend_func_separate(BlendFunc.src_alpha, BlendFunc.one_minus_src_alpha,
# BlendFunc.one, BlendFunc.zero)
surface.set_alignment(Origin.center)
surface.set_alpha(0.5)
# surface.set_scale(DrawerProperties.current.get_size(),
# DrawerProperties.current.get_size())
surface.draw(dab.pos.x, dab.pos.y, gc.gc)
else:
print("Error: SpriteStrokeDrawer: Unknown draw mode: ",
self.mode)
else:
if self.mode == SpriteStrokeDrawer.DM_NORMAL:
sprite.set_blend_func(BlendFunc.src_alpha,
BlendFunc.one_minus_src_alpha)
sprite.draw(dab.pos.x, dab.pos.y, gc.gc)
elif self.mode == SpriteStrokeDrawer.DM_ADDITION:
sprite.set_blend_func(BlendFunc.src_alpha, BlendFunc.one)
sprite.draw(dab.pos.x, dab.pos.y, gc.gc)
elif self.mode == SpriteStrokeDrawer.DM_ERASE:
sprite.set_blend_func(BlendFunc.zero,
BlendFunc.one_minus_src_alpha)
sprite.draw(dab.pos.x, dab.pos.y, gc.gc)
elif self.mode == SpriteStrokeDrawer.DM_SMUDGE:
sprite.set_blend_func(BlendFunc.src_alpha,
BlendFunc.one_minus_src_alpha)
sprite.draw(dab.pos.x, dab.pos.y, gc.gc)
else:
print("Error: SpriteStrokeDrawer: Unknown draw mode:",
self.mode)
