Map Window Zoom

[loweboy]

I'm trying to figure out how I could implement a feature to zoom in and out of the map window, but I can't seem to figure out which part of the system is controlling the size of the map in the UI.

Any help would be greatly appreciated.

[KoBeWi]

You can zoom-in/out by scaling the CanvasItem that draws MapView.

[loweboy]

Thanks for the reply.

I was trying do just what you suggested, and thought it wasn't the solution because it kept putting my view off center.

I figured out that I needed to adjust the pivot.

self.pivot_offset = self.size / 2.

Here is the modified script In case it helps anyone else.

I put -comment- instead of the hashtag for comments because it made them display as a heading.

-comment- The window that contains a bigger map overview than minimap. Toggled with M.
extends Panel

@onready var player: CharacterBody2D = %Player
@onready var minimap: Control = %Minimap
@onready var top_draw: Control = $TopDraw

-comment- The size of the window in cells.
var SIZE: Vector2i
var initial_scale: Vector2
-comment- New zoom level variable. Default to 1.0 (no zoom).
var zoom_level: float = 1.0
-comment- MapView object that draws cells.
var map_view: MapView

-comment- The position where the player started (for the vector feature).
var starting_coords: Vector2i
-comment- The player location node from MetSys.add_player_location()
var player_location: Node2D
-comment- The vector feature, toggled with D. It displays an arrow from player's starting point to the current position.
-comment- It's purely to show custom drawing on the map.
var show_delta: bool
-comment- The offset for drawing delta vector, updated with map panning.
var offset: Vector2i

func _ready() -> void:
self.pivot_offset = self.size / 2
zoom_level = 2.5
-comment- Cellular size is total size divided by cell size.
SIZE = size / MetSys.CELL_SIZE
map_view = MetSys.make_map_view(self, -SIZE / 2, SIZE, 0)
initial_scale = self.scale
print(initial_scale)
-comment- Create player location. We need a reference to update its offset.
player_location = MetSys.add_player_location(self)

-comment- Draws the delta vector. Note that TopDraw node is used, to make sure that it appears above cells.
func _on_top_draw() -> void:
-comment- Get the current player coordinates.
var coords := MetSys.get_current_flat_coords()
-comment- If the delta vector (D) is enabled and player isn't on the starting position...
if show_delta and coords != starting_coords:
var start_pos := MetSys.get_cell_position(starting_coords - offset)
var current_pos := MetSys.get_cell_position(coords - offset)
-comment- draw the vector...
top_draw.draw_line(start_pos, current_pos, Color.WHITE, 2)

	const arrow_size = 4
	-comment- and arrow. This code shows how to draw custom stuff on the map outside the MetSys functions.
	top_draw.draw_set_transform(current_pos, start_pos.angle_to_point(current_pos), Vector2.ONE)
	top_draw.draw_primitive([Vector2(-arrow_size, -arrow_size), Vector2(arrow_size, 0), Vector2(-arrow_size, arrow_size)], [Color.WHITE], [])

func _input(event: InputEvent) -> void:
-comment-if event is InputEventKey:
-comment-if event.is_pressed():

		-comment- Toggle visibility when pressing M.
		if Input.is_action_just_pressed("map"):
		-comment-if event.keycode == KEY_M:
			visible = not visible
			minimap.visible = not visible -comment- Make minimap invisible when full map is visible.
			
			if visible:
				-comment- Pause the player when opening map.
				player.process_mode = Node.PROCESS_MODE_DISABLED
				-comment- Update map offset when opening it.
				update_offset()
			else:
				player.process_mode = Node.PROCESS_MODE_INHERIT
		elif Input.is_action_just_pressed("jump"):
			-comment- D toggles position tracking (delta vector).
			show_delta = not show_delta
			top_draw.queue_redraw()
		elif visible:
			-comment- Move with arrow keys.
			var move_offset: Vector2i
			if Input.is_action_pressed("left"):
				move_offset = Vector2i.LEFT
			elif Input.is_action_pressed("right"):
				move_offset = Vector2i.RIGHT
			elif Input.is_action_pressed("up"):
				move_offset = Vector2i.UP
			elif Input.is_action_pressed("down"):
				move_offset = Vector2i.DOWN
			elif Input.is_action_pressed("dash"):
				zoom_level += 0.1
				update_zoom()
			elif Input.is_action_pressed("pound"):
				zoom_level -= 0.1
				update_zoom()	
			
				

			
			-comment- This moves the MapView's visible area, ensuring that only newly visible cells are redrawn.
			map_view.move(move_offset)
			-comment- Player position node needs to be moved accordingly.
			player_location.offset = -Vector2(map_view.begin) * MetSys.CELL_SIZE
			-comment- Update delta vector.
			offset += move_offset
			top_draw.queue_redraw()

-comment- Assigns the initial offset when the map is opened. It centers on the player position.

func update_offset():
offset = MetSys.get_current_flat_coords() - SIZE / 2
-comment- Player position node needs to be moved accordingly.
player_location.offset = -Vector2(offset) * MetSys.CELL_SIZE
-comment- Updates map view initial position.
map_view.move_to(Vector3i(offset.x, offset.y, MetSys.current_layer))
-comment- Update all cells of MapView to reflect the current state.
map_view.update_all()

func reset_starting_coords():
-comment- Starting position for the delta vector.
var coords := MetSys.get_current_flat_coords()
starting_coords = Vector2i(coords.x, coords.y)
top_draw.queue_redraw()

func update_zoom():
-comment- Clamp the zoom level to a valid range.
zoom_level = clamp(zoom_level, 2.0, 5.0)

-comment- Apply the new scale to the Panel itself. This scales the entire UI element.
self.scale = initial_scale * zoom_level

-comment- Recenter the map on the player after the scale change.
update_offset()

top_draw.queue_redraw()