256 lines
10 KiB
GDScript
256 lines
10 KiB
GDScript
extends Node
|
|
class_name IsometricMapRenderer
|
|
|
|
var map_data = null
|
|
var isometric_map_layers = []
|
|
var highlighted_tiles = {} # Dictionary to store all currently highlighted tiles
|
|
|
|
var TILE_SIZE_ISOMETRIC_X = 32 # in px
|
|
var TILE_SIZE_ISOMETRIC_Y = 16 # in px
|
|
|
|
var unit_is_hovered = false
|
|
var unit_is_selected = false
|
|
|
|
|
|
var darkening_active = false
|
|
var original_modulates = {}
|
|
|
|
func darken_all_except_player(player_node):
|
|
darkening_active = true
|
|
|
|
# Store original modulate values
|
|
for layer in isometric_map_layers:
|
|
original_modulates[layer] = layer.modulate
|
|
# Darken the layer
|
|
layer.modulate = Color(0.5, 0.5, 0.5, 1.0)
|
|
|
|
# Keep player at normal brightness
|
|
player_node.modulate = Color(1.0, 1.0, 1.0, 1.0)
|
|
|
|
func reset_darkening():
|
|
darkening_active = false
|
|
|
|
# Restore original modulate values
|
|
for layer in isometric_map_layers:
|
|
if layer in original_modulates:
|
|
layer.modulate = original_modulates[layer]
|
|
|
|
func set_unit_hover_state(is_hovered):
|
|
unit_is_hovered = is_hovered
|
|
|
|
func set_unit_selected_state(is_selected):
|
|
unit_is_selected = is_selected
|
|
|
|
# Initialize with reference to a map data object and a tilemap to use as template
|
|
func _init(map_data_ref, tilemap_template):
|
|
map_data = map_data_ref
|
|
initialize_map_layers(tilemap_template)
|
|
|
|
# Initialize all the map layers for different heights
|
|
func initialize_map_layers(tilemap_template):
|
|
# Clear any existing layers
|
|
for layer in isometric_map_layers:
|
|
if is_instance_valid(layer):
|
|
layer.queue_free()
|
|
|
|
isometric_map_layers.clear()
|
|
|
|
# Create new layers for each height level
|
|
for z in map_data.GRID_SIZE_HEIGHT:
|
|
var new_layer = TileMapLayer.new()
|
|
new_layer.set_name("IsometricMapLayer_" + str(z))
|
|
new_layer.tile_set = tilemap_template.tile_set
|
|
new_layer.z_index = z # Set the z-index to match the layer's height
|
|
|
|
tilemap_template.get_parent().add_child(new_layer)
|
|
isometric_map_layers.append(new_layer)
|
|
|
|
# Draw all visible tiles on the map
|
|
func draw_visible_tiles():
|
|
# Clear all previously drawn tiles on each layer
|
|
for layer in isometric_map_layers:
|
|
layer.clear()
|
|
|
|
# Draw the map
|
|
for z in map_data.GRID_SIZE_HEIGHT:
|
|
for y in map_data.GRID_SIZE_LENGTH:
|
|
for x in map_data.GRID_SIZE_WIDTH:
|
|
var tile = map_data.get_tile(x, y, z)
|
|
if tile != null and tile["visibility"] and tile["atlas_base_position"] != null:
|
|
# Use the layer that corresponds to the tile's z-value
|
|
if z < isometric_map_layers.size():
|
|
isometric_map_layers[z].set_cell(
|
|
Vector2i(tile["x"], tile["y"]),
|
|
IsometricMapSystem.MAIN_SOURCE_ID,
|
|
tile["atlas_base_position"]
|
|
)
|
|
|
|
# Handle hovering over tiles
|
|
func handle_hover(mouse_position):
|
|
var hover_tile_position = isometric_map_layers[0].local_to_map(mouse_position)
|
|
var new_highlighted_tiles = {} # Will store tiles to highlight this frame
|
|
|
|
if unit_is_hovered:
|
|
# De-highlight all tiles
|
|
for tile_key in highlighted_tiles:
|
|
var tile_data = highlighted_tiles[tile_key]
|
|
var tile = map_data.get_tile(tile_data.x, tile_data.y, tile_data.z)
|
|
|
|
if tile != null and tile["visibility"] and not tile["unit"]:
|
|
if not tile["selected"]:
|
|
if tile["atlas_base_position"] != null:
|
|
isometric_map_layers[tile_data.z].set_cell(
|
|
Vector2i(tile["x"], tile["y"]),
|
|
IsometricMapSystem.MAIN_SOURCE_ID,
|
|
tile["atlas_base_position"]
|
|
)
|
|
tile["highlighted"] = false
|
|
|
|
highlighted_tiles = {}
|
|
return
|
|
|
|
# First find all tiles that should be highlighted
|
|
for z in map_data.GRID_SIZE_HEIGHT:
|
|
for x in map_data.GRID_SIZE_WIDTH:
|
|
for y in map_data.GRID_SIZE_LENGTH:
|
|
var tile = map_data.get_tile(x, y, z)
|
|
var tile_above = map_data.get_tile(x, y, z + 1)
|
|
if tile_above != null and tile_above["visibility"] and not tile_above["unit"]:
|
|
if tile["x"] == hover_tile_position.x and tile["y"] == hover_tile_position.y:
|
|
# Store this tile for highlighting
|
|
var tile_key = str(x) + "_" + str(y) + "_" + str(z)
|
|
|
|
new_highlighted_tiles[tile_key] = {
|
|
"x": x,
|
|
"y": y,
|
|
"z": z + 1
|
|
}
|
|
elif tile != null and tile["visibility"] and not tile["unit"]:
|
|
if tile["x"] == hover_tile_position.x and tile["y"] == hover_tile_position.y:
|
|
# Store this tile for highlighting
|
|
var tile_key = str(x) + "_" + str(y) + "_" + str(z)
|
|
|
|
new_highlighted_tiles[tile_key] = {
|
|
"x": x,
|
|
"y": y,
|
|
"z": z
|
|
}
|
|
|
|
# Highlight new tiles
|
|
for tile_key in new_highlighted_tiles:
|
|
var tile_data = new_highlighted_tiles[tile_key]
|
|
var tile = map_data.get_tile(tile_data.x, tile_data.y, tile_data.z)
|
|
if tile == null:
|
|
continue
|
|
|
|
if not tile["selected"] and not tile["unit"]:
|
|
# Only set cell if we have a valid highlight position
|
|
if tile["atlas_highlight_position"] != null:
|
|
isometric_map_layers[tile_data.z].set_cell(
|
|
Vector2i(tile["x"], tile["y"]),
|
|
IsometricMapSystem.MAIN_SOURCE_ID,
|
|
tile["atlas_highlight_position"]
|
|
)
|
|
else:
|
|
isometric_map_layers[tile_data.z].set_cell(
|
|
Vector2i(tile["x"], tile["y"]),
|
|
1,
|
|
Vector2i(3,1) #
|
|
)
|
|
|
|
tile["highlighted"] = true
|
|
|
|
# De-highlight tiles that are no longer under the cursor
|
|
for tile_key in highlighted_tiles:
|
|
if not (tile_key in new_highlighted_tiles):
|
|
var tile_data = highlighted_tiles[tile_key]
|
|
var tile = map_data.get_tile(tile_data.x, tile_data.y, tile_data.z)
|
|
|
|
if tile != null and tile["visibility"] and not tile["unit"]:
|
|
|
|
if not tile["selected"]:
|
|
# Only set cell if we have a valid base position
|
|
if tile["atlas_base_position"] != null:
|
|
isometric_map_layers[tile_data.z].set_cell(
|
|
Vector2i(tile["x"], tile["y"]),
|
|
IsometricMapSystem.MAIN_SOURCE_ID,
|
|
tile["atlas_base_position"] # Original appearance
|
|
)
|
|
else:
|
|
isometric_map_layers[tile_data.z].set_cell(
|
|
Vector2i(tile["x"], tile["y"]),
|
|
1,
|
|
Vector2i(0,1) #
|
|
)
|
|
tile["highlighted"] = false
|
|
|
|
# Update the highlighted tiles list
|
|
highlighted_tiles = new_highlighted_tiles
|
|
|
|
# Handle tile selection logic
|
|
func handle_tile_selection():
|
|
if unit_is_selected:
|
|
reset_darkening()
|
|
unit_is_selected = false
|
|
|
|
for z in map_data.GRID_SIZE_HEIGHT:
|
|
for x in map_data.GRID_SIZE_WIDTH:
|
|
for y in map_data.GRID_SIZE_LENGTH:
|
|
var tile = map_data.get_tile(x, y, z)
|
|
if tile == null or not tile["visibility"]:
|
|
continue
|
|
|
|
# Get valid coordinates
|
|
var tile_x = tile["x"]
|
|
var tile_y = tile["y"]
|
|
|
|
if tile["selected"] and tile["highlighted"]:
|
|
print("direct de selected: ", Vector2i(tile_x, tile_y))
|
|
isometric_map_layers[z].set_cell(
|
|
Vector2i(tile_x, tile_y),
|
|
IsometricMapSystem.MAIN_SOURCE_ID,
|
|
IsometricMapSystem.SELECTED_BLUE_ISOMETRICTILE_ATLAS_POSITION
|
|
)
|
|
tile["selected"] = false
|
|
|
|
elif tile["selected"] and not tile["highlighted"]:
|
|
print("old de selected: ", Vector2i(tile_x, tile_y))
|
|
# If there's a base position, restore it, otherwise use a default
|
|
if tile["atlas_base_position"] != null:
|
|
isometric_map_layers[z].set_cell(
|
|
Vector2i(tile_x, tile_y),
|
|
IsometricMapSystem.MAIN_SOURCE_ID,
|
|
tile["atlas_base_position"]
|
|
)
|
|
else:
|
|
isometric_map_layers[z].set_cell(
|
|
Vector2i(tile_x, tile_y),
|
|
IsometricMapSystem.MAIN_SOURCE_ID,
|
|
IsometricMapSystem.BLUE_ISOMETRICTILE_ATLAS_POSITION
|
|
)
|
|
tile["selected"] = false
|
|
|
|
elif not tile["selected"] and tile["highlighted"]:
|
|
print("new selected: ", Vector2i(tile_x, tile_y))
|
|
isometric_map_layers[z].set_cell(
|
|
Vector2i(tile_x, tile_y),
|
|
IsometricMapSystem.MAIN_SOURCE_ID,
|
|
IsometricMapSystem.SELECTED_WHITE_ISOMETRICTILE_ATLAS_POSITION
|
|
)
|
|
tile["selected"] = true
|
|
|
|
# Position a unit on the map visually
|
|
func position_unit(unit, tile_x, tile_y, tile_z):
|
|
var world_pos = IsometricMapSystem.iso_to_world(
|
|
tile_x,
|
|
tile_y,
|
|
tile_z,
|
|
TILE_SIZE_ISOMETRIC_X,
|
|
TILE_SIZE_ISOMETRIC_Y
|
|
)
|
|
|
|
unit.z_index = tile_z
|
|
# Assuming unit has a set_unit_position method to handle actual positioning
|
|
if unit.has_method("set_unit_position"):
|
|
unit.set_unit_position(world_pos.x, world_pos.y, tile_z)
|