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)