Jonas/itrpg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tried to change the higlighting, did not work

Browse Source
This commit is contained in:
Jonas 2025-03-24 22:21:28 +01:00
parent 48ee4b49ea
commit e55dc546e3
4 changed files with 519 additions and 501 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
scripts/debug_level.gd
View File

@ -1,4 +1,4 @@
extends Node2D extends Node2D
func _process(delta: float) -> void: func _process(_delta: float) -> void:
pass pass

846
scripts/isometric_map_layer_holder.gd
View File

@ -35,543 +35,561 @@ const OFFSET = 0
var MAX_ARRAY_SIZE = 0 var MAX_ARRAY_SIZE = 0
func _set_max_array_size(): func _set_max_array_size():
MAX_ARRAY_SIZE = 0 MAX_ARRAY_SIZE = 0
if MAX_ARRAY_SIZE < GRID_SIZE_WIDTH: if MAX_ARRAY_SIZE < GRID_SIZE_WIDTH:
MAX_ARRAY_SIZE = GRID_SIZE_WIDTH MAX_ARRAY_SIZE = GRID_SIZE_WIDTH
if MAX_ARRAY_SIZE < GRID_SIZE_LENGTH: if MAX_ARRAY_SIZE < GRID_SIZE_LENGTH:
MAX_ARRAY_SIZE = GRID_SIZE_LENGTH MAX_ARRAY_SIZE = GRID_SIZE_LENGTH
if MAX_ARRAY_SIZE < GRID_SIZE_HEIGHT: if MAX_ARRAY_SIZE < GRID_SIZE_HEIGHT:
MAX_ARRAY_SIZE = GRID_SIZE_HEIGHT MAX_ARRAY_SIZE = GRID_SIZE_HEIGHT
func create_debug_map_array(): func create_debug_map_array():
var _debug_map = [] var _debug_map = []
_set_max_array_size() _set_max_array_size()
for x in MAX_ARRAY_SIZE: for x in MAX_ARRAY_SIZE:
var y_array = [] var y_array = []
for y in MAX_ARRAY_SIZE: for y in MAX_ARRAY_SIZE:
var z_array = [] var z_array = []
for z in MAX_ARRAY_SIZE: for z in MAX_ARRAY_SIZE:
z_array.append(null) z_array.append(null)
y_array.append(z_array) y_array.append(z_array)
_debug_map.append(y_array) _debug_map.append(y_array)
for z in INITIAL_GRID_SIZE_HEIGHT: for z in INITIAL_GRID_SIZE_HEIGHT:
for y in INITIAL_GRID_SIZE_LENGTH: for y in INITIAL_GRID_SIZE_LENGTH:
for x in INITIAL_GRID_SIZE_WIDTH: for x in INITIAL_GRID_SIZE_WIDTH:
var coord_x = x + (-1 * z) + OFFSET var coord_x = x + (-1 * z) + OFFSET
var coord_y = y + (-1 * z) - OFFSET var coord_y = y + (-1 * z) - OFFSET
var tile_data = { var tile_data = {
"x": coord_x, "x": coord_x,
"y": coord_y, "y": coord_y,
"z": z, "z": z,
"atlas_base_position": null, "atlas_base_position": null,
"atlas_highlight_position": null, "atlas_highlight_position": null,
"highlighted": false, "highlighted": false,
"selected": false, "selected": false,
"hp": 100, "hp": 100,
"armour": 0, "armour": 0,
"destroyable": false, "destroyable": false,
"visibility": false, "visibility": false,
"unit": null, "unit": null,
"gravity": null "gravity": null
} }
_debug_map[x][y][z] = tile_data _debug_map[x][y][z] = tile_data
var tile = _debug_map[0][0][0] var tile = _debug_map[0][0][0]
for y in INITIAL_GRID_SIZE_LENGTH: for y in INITIAL_GRID_SIZE_LENGTH:
for x in INITIAL_GRID_SIZE_WIDTH: for x in INITIAL_GRID_SIZE_WIDTH:
tile = _debug_map[x][y][0] tile = _debug_map[x][y][0]
tile["atlas_base_position"] = BLUE_ISOMETRICTILE_ATLAS_POSITION tile["atlas_base_position"] = BLUE_ISOMETRICTILE_ATLAS_POSITION
tile["atlas_highlight_position"] = WHITE_ISOMETRICTILE_ATLAS_POSITION tile["atlas_highlight_position"] = WHITE_ISOMETRICTILE_ATLAS_POSITION
tile["visibility"] = true tile["visibility"] = true
for i in range(1,10): for i in range(1,10):
tile = _debug_map[5][5][i] tile = _debug_map[5][5][i]
tile["atlas_base_position"] = RED_ISOMETRICTILE_ATLAS_POSITION tile["atlas_base_position"] = RED_ISOMETRICTILE_ATLAS_POSITION
tile["atlas_highlight_position"] = WHITE_ISOMETRICTILE_ATLAS_POSITION tile["atlas_highlight_position"] = WHITE_ISOMETRICTILE_ATLAS_POSITION
tile["visibility"] = true tile["visibility"] = true
# for y in INITIAL_GRID_SIZE_LENGTH: # for y in INITIAL_GRID_SIZE_LENGTH:
# for x in INITIAL_GRID_SIZE_WIDTH: # for x in INITIAL_GRID_SIZE_WIDTH:
# tile = _debug_map[x][y][INITIAL_GRID_SIZE_HEIGHT-1] # tile = _debug_map[x][y][INITIAL_GRID_SIZE_HEIGHT-1]
# tile["atlas_position"] = BLUE_ISOMETRICTILE_ATLAS_POSITION # tile["atlas_position"] = BLUE_ISOMETRICTILE_ATLAS_POSITION
# tile["visibility"] = true # tile["visibility"] = true
# for z in range(1,INITIAL_GRID_SIZE_HEIGHT-1): # for z in range(1,INITIAL_GRID_SIZE_HEIGHT-1):
# for x in INITIAL_GRID_SIZE_WIDTH: # for x in INITIAL_GRID_SIZE_WIDTH:
# tile = _debug_map[x][0][z] # tile = _debug_map[x][0][z]
# tile["atlas_position"] = GREEN_ISOMETRICTILE_ATLAS_POSITION # tile["atlas_position"] = GREEN_ISOMETRICTILE_ATLAS_POSITION
# tile["visibility"] = true # tile["visibility"] = true
# for z in range(1,INITIAL_GRID_SIZE_HEIGHT-1): # for z in range(1,INITIAL_GRID_SIZE_HEIGHT-1):
# for x in INITIAL_GRID_SIZE_WIDTH: # for x in INITIAL_GRID_SIZE_WIDTH:
# tile = _debug_map[x][INITIAL_GRID_SIZE_LENGTH-1][z] # tile = _debug_map[x][INITIAL_GRID_SIZE_LENGTH-1][z]
# tile["atlas_position"] = GREEN_ISOMETRICTILE_ATLAS_POSITION # tile["atlas_position"] = GREEN_ISOMETRICTILE_ATLAS_POSITION
# tile["visibility"] = true # tile["visibility"] = true
# for z in range(1,INITIAL_GRID_SIZE_HEIGHT-1): # for z in range(1,INITIAL_GRID_SIZE_HEIGHT-1):
# for y in range(1,INITIAL_GRID_SIZE_LENGTH-1): # for y in range(1,INITIAL_GRID_SIZE_LENGTH-1):
# tile = _debug_map[0][y][z] # tile = _debug_map[0][y][z]
# tile["atlas_position"] = BLACK_ISOMETRICTILE_ATLAS_POSITION # tile["atlas_position"] = BLACK_ISOMETRICTILE_ATLAS_POSITION
# tile["visibility"] = true # tile["visibility"] = true
# for z in range(1,INITIAL_GRID_SIZE_HEIGHT-1): # for z in range(1,INITIAL_GRID_SIZE_HEIGHT-1):
# for y in range(1,INITIAL_GRID_SIZE_LENGTH-1): # for y in range(1,INITIAL_GRID_SIZE_LENGTH-1):
# tile = _debug_map[INITIAL_GRID_SIZE_WIDTH-1][y][z] # tile = _debug_map[INITIAL_GRID_SIZE_WIDTH-1][y][z]
# tile["atlas_position"] = RED_ISOMETRICTILE_ATLAS_POSITION # tile["atlas_position"] = RED_ISOMETRICTILE_ATLAS_POSITION
# tile["visibility"] = true # tile["visibility"] = true
GRID_SIZE_WIDTH = INITIAL_GRID_SIZE_WIDTH # play area size x GRID_SIZE_WIDTH = INITIAL_GRID_SIZE_WIDTH # play area size x
GRID_SIZE_LENGTH = INITIAL_GRID_SIZE_LENGTH # play area size y GRID_SIZE_LENGTH = INITIAL_GRID_SIZE_LENGTH # play area size y
GRID_SIZE_HEIGHT = INITIAL_GRID_SIZE_HEIGHT # play area size z GRID_SIZE_HEIGHT = INITIAL_GRID_SIZE_HEIGHT # play area size z
return _debug_map return _debug_map
func rotate_map_around_x_axis(rotation_steps = 1): func rotate_map_around_x_axis(rotation_steps = 1):
rotation_steps = rotation_steps % 4 rotation_steps = rotation_steps % 4
if rotation_steps == 0: if rotation_steps == 0:
return return
var temp_map = [] var temp_map = []
# Initialize temp_map with same structure # Initialize temp_map with same structure
_set_max_array_size() _set_max_array_size()
for x in MAX_ARRAY_SIZE: for x in MAX_ARRAY_SIZE:
var y_array = [] var y_array = []
for y in MAX_ARRAY_SIZE: for y in MAX_ARRAY_SIZE:
var z_array = [] var z_array = []
for z in MAX_ARRAY_SIZE: for z in MAX_ARRAY_SIZE:
z_array.append(null) z_array.append(null)
y_array.append(z_array) y_array.append(z_array)
temp_map.append(y_array) temp_map.append(y_array)
# Create a new map with adjusted dimensions # Create a new map with adjusted dimensions
var new_height = int(GRID_SIZE_LENGTH) if rotation_steps % 2 == 1 else int(GRID_SIZE_HEIGHT) var new_height = int(GRID_SIZE_LENGTH) if rotation_steps % 2 == 1 else int(GRID_SIZE_HEIGHT)
var new_length = int(GRID_SIZE_HEIGHT) if rotation_steps % 2 == 1 else int(GRID_SIZE_LENGTH) var new_length = int(GRID_SIZE_HEIGHT) if rotation_steps % 2 == 1 else int(GRID_SIZE_LENGTH)
# Store the original dimensions # Store the original dimensions
var original_height = GRID_SIZE_HEIGHT var original_height = GRID_SIZE_HEIGHT
var original_length = GRID_SIZE_LENGTH var original_length = GRID_SIZE_LENGTH
# Temporarily adjust grid dimensions for coordinate calculation # Temporarily adjust grid dimensions for coordinate calculation
GRID_SIZE_HEIGHT = new_height GRID_SIZE_HEIGHT = new_height
GRID_SIZE_LENGTH = new_length GRID_SIZE_LENGTH = new_length
for x in GRID_SIZE_WIDTH: for x in GRID_SIZE_WIDTH:
for y in original_length: for y in original_length:
for z in original_height: for z in original_height:
if debug_map[x][y][z] == null: if debug_map[x][y][z] == null:
continue continue
var new_y = 0 var new_y = 0
var new_z = 0 var new_z = 0
match rotation_steps: match rotation_steps:
1: # 90 degrees 1: # 90 degrees
new_y = z new_y = z
new_z = original_length - 1 - y new_z = original_length - 1 - y
2: # 180 degrees 2: # 180 degrees
new_y = original_length - 1 - y new_y = original_length - 1 - y
new_z = original_height - 1 - z new_z = original_height - 1 - z
3: # 270 degrees 3: # 270 degrees
new_y = original_height - 1 - z new_y = original_height - 1 - z
new_z = y new_z = y
if new_y >= 0 and new_y < new_length and new_z >= 0 and new_z < new_height: if new_y >= 0 and new_y < new_length and new_z >= 0 and new_z < new_height:
temp_map[x][new_y][new_z] = debug_map[x][y][z].duplicate() temp_map[x][new_y][new_z] = debug_map[x][y][z].duplicate()
var new_coord_x = x + (-1 * new_z) + OFFSET var new_coord_x = x + (-1 * new_z) + OFFSET
var new_coord_y = new_y + (-1 * new_z) - OFFSET var new_coord_y = new_y + (-1 * new_z) - OFFSET
temp_map[x][new_y][new_z]["x"] = new_coord_x temp_map[x][new_y][new_z]["x"] = new_coord_x
temp_map[x][new_y][new_z]["y"] = new_coord_y temp_map[x][new_y][new_z]["y"] = new_coord_y
temp_map[x][new_y][new_z]["z"] = new_z temp_map[x][new_y][new_z]["z"] = new_z
# Update the grid dimensions # Update the grid dimensions
GRID_SIZE_HEIGHT = new_height GRID_SIZE_HEIGHT = new_height
GRID_SIZE_LENGTH = new_length GRID_SIZE_LENGTH = new_length
debug_map = temp_map debug_map = temp_map
func rotate_map_around_y_axis(rotation_steps = 1): func rotate_map_around_y_axis(rotation_steps = 1):
rotation_steps = rotation_steps % 4 rotation_steps = rotation_steps % 4
if rotation_steps == 0: if rotation_steps == 0:
return return
var temp_map = [] var temp_map = []
# Initialize temp_map with same structure # Initialize temp_map with same structure
_set_max_array_size() _set_max_array_size()
for x in MAX_ARRAY_SIZE: for x in MAX_ARRAY_SIZE:
var y_array = [] var y_array = []
for y in MAX_ARRAY_SIZE: for y in MAX_ARRAY_SIZE:
var z_array = [] var z_array = []
for z in MAX_ARRAY_SIZE: for z in MAX_ARRAY_SIZE:
z_array.append(null) z_array.append(null)
y_array.append(z_array) y_array.append(z_array)
temp_map.append(y_array) temp_map.append(y_array)
# Create a new map with adjusted dimensions # Create a new map with adjusted dimensions
var new_width = int(GRID_SIZE_HEIGHT) if rotation_steps % 2 == 1 else int(GRID_SIZE_WIDTH) var new_width = int(GRID_SIZE_HEIGHT) if rotation_steps % 2 == 1 else int(GRID_SIZE_WIDTH)
var new_height = int(GRID_SIZE_WIDTH) if rotation_steps % 2 == 1 else int(GRID_SIZE_HEIGHT) var new_height = int(GRID_SIZE_WIDTH) if rotation_steps % 2 == 1 else int(GRID_SIZE_HEIGHT)
# Store the original dimensions # Store the original dimensions
var original_width = GRID_SIZE_WIDTH var original_width = GRID_SIZE_WIDTH
var original_height = GRID_SIZE_HEIGHT var original_height = GRID_SIZE_HEIGHT
# Temporarily adjust grid dimensions for coordinate calculation # Temporarily adjust grid dimensions for coordinate calculation
GRID_SIZE_WIDTH = new_width GRID_SIZE_WIDTH = new_width
GRID_SIZE_HEIGHT = new_height GRID_SIZE_HEIGHT = new_height
for x in original_width: for x in original_width:
for y in GRID_SIZE_LENGTH: for y in GRID_SIZE_LENGTH:
for z in original_height: for z in original_height:
if debug_map[x][y][z] == null: if debug_map[x][y][z] == null:
continue continue
var new_x = 0 var new_x = 0
var new_z = 0 var new_z = 0
match rotation_steps: match rotation_steps:
1: # 90 degrees clockwise around Y axis 1: # 90 degrees clockwise around Y axis
new_x = original_height - 1 - z new_x = original_height - 1 - z
new_z = x new_z = x
2: # 180 degrees 2: # 180 degrees
new_x = original_width - 1 - x new_x = original_width - 1 - x
new_z = original_height - 1 - z new_z = original_height - 1 - z
3: # 270 degrees 3: # 270 degrees
new_x = z new_x = z
new_z = original_width - 1 - x new_z = original_width - 1 - x
if new_x >= 0 and new_x < new_width and new_z >= 0 and new_z < new_height: if new_x >= 0 and new_x < new_width and new_z >= 0 and new_z < new_height:
temp_map[new_x][y][new_z] = debug_map[x][y][z].duplicate() temp_map[new_x][y][new_z] = debug_map[x][y][z].duplicate()
var new_coord_x = new_x + (-1 * new_z) + OFFSET var new_coord_x = new_x + (-1 * new_z) + OFFSET
var new_coord_y = y + (-1 * new_z) - OFFSET var new_coord_y = y + (-1 * new_z) - OFFSET
temp_map[new_x][y][new_z]["x"] = new_coord_x temp_map[new_x][y][new_z]["x"] = new_coord_x
temp_map[new_x][y][new_z]["y"] = new_coord_y temp_map[new_x][y][new_z]["y"] = new_coord_y
temp_map[new_x][y][new_z]["z"] = new_z temp_map[new_x][y][new_z]["z"] = new_z
# Update the grid dimensions # Update the grid dimensions
GRID_SIZE_WIDTH = new_width GRID_SIZE_WIDTH = new_width
GRID_SIZE_HEIGHT = new_height GRID_SIZE_HEIGHT = new_height
debug_map = temp_map debug_map = temp_map
func rotate_map_around_z_axis(rotation_steps = 1): func rotate_map_around_z_axis(rotation_steps = 1):
rotation_steps = rotation_steps % 4 rotation_steps = rotation_steps % 4
if rotation_steps == 0: if rotation_steps == 0:
return return
var temp_map = [] var temp_map = []
# Initialize temp_map with same structure # Initialize temp_map with same structure
_set_max_array_size() _set_max_array_size()
for x in MAX_ARRAY_SIZE: for x in MAX_ARRAY_SIZE:
var y_array = [] var y_array = []
for y in MAX_ARRAY_SIZE: for y in MAX_ARRAY_SIZE:
var z_array = [] var z_array = []
for z in MAX_ARRAY_SIZE: for z in MAX_ARRAY_SIZE:
z_array.append(null) z_array.append(null)
y_array.append(z_array) y_array.append(z_array)
temp_map.append(y_array) temp_map.append(y_array)
# Create a new map with adjusted dimensions based on rotation # Create a new map with adjusted dimensions based on rotation
var new_width = int(GRID_SIZE_LENGTH) if rotation_steps % 2 == 1 else int(GRID_SIZE_WIDTH) var new_width = int(GRID_SIZE_LENGTH) if rotation_steps % 2 == 1 else int(GRID_SIZE_WIDTH)
var new_length = int(GRID_SIZE_WIDTH) if rotation_steps % 2 == 1 else int(GRID_SIZE_LENGTH) var new_length = int(GRID_SIZE_WIDTH) if rotation_steps % 2 == 1 else int(GRID_SIZE_LENGTH)
# Store the original dimensions # Store the original dimensions
var original_width = GRID_SIZE_WIDTH var original_width = GRID_SIZE_WIDTH
var original_length = GRID_SIZE_LENGTH var original_length = GRID_SIZE_LENGTH
# Temporarily adjust grid dimensions for coordinate calculation # Temporarily adjust grid dimensions for coordinate calculation
GRID_SIZE_WIDTH = new_width GRID_SIZE_WIDTH = new_width
GRID_SIZE_LENGTH = new_length GRID_SIZE_LENGTH = new_length
for x in original_width: for x in original_width:
for y in original_length: for y in original_length:
for z in GRID_SIZE_HEIGHT: for z in GRID_SIZE_HEIGHT:
if debug_map[x][y][z] == null: if debug_map[x][y][z] == null:
continue continue
var new_x = 0 var new_x = 0
var new_y = 0 var new_y = 0
match rotation_steps: match rotation_steps:
1: # 90 degrees 1: # 90 degrees
new_x = y new_x = y
new_y = original_width - 1 - x new_y = original_width - 1 - x
2: # 180 degrees 2: # 180 degrees
new_x = original_width - 1 - x new_x = original_width - 1 - x
new_y = original_length - 1 - y new_y = original_length - 1 - y
3: # 270 degrees 3: # 270 degrees
new_x = original_length - 1 - y new_x = original_length - 1 - y
new_y = x new_y = x
if new_x >= 0 and new_x < new_width and new_y >= 0 and new_y < new_length: if new_x >= 0 and new_x < new_width and new_y >= 0 and new_y < new_length:
temp_map[new_x][new_y][z] = debug_map[x][y][z].duplicate() temp_map[new_x][new_y][z] = debug_map[x][y][z].duplicate()
var new_coord_x = new_x + (-1 * z) + OFFSET var new_coord_x = new_x + (-1 * z) + OFFSET
var new_coord_y = new_y + (-1 * z) - OFFSET var new_coord_y = new_y + (-1 * z) - OFFSET
temp_map[new_x][new_y][z]["x"] = new_coord_x temp_map[new_x][new_y][z]["x"] = new_coord_x
temp_map[new_x][new_y][z]["y"] = new_coord_y temp_map[new_x][new_y][z]["y"] = new_coord_y
temp_map[new_x][new_y][z]["z"] = z temp_map[new_x][new_y][z]["z"] = z
# Update the grid dimensions # Update the grid dimensions
GRID_SIZE_WIDTH = new_width GRID_SIZE_WIDTH = new_width
GRID_SIZE_LENGTH = new_length GRID_SIZE_LENGTH = new_length
debug_map = temp_map debug_map = temp_map
var isometric_map_layers = [] var isometric_map_layers = []
func initialize_map_layers(): func initialize_map_layers():
# Clear any existing layers # Clear any existing layers
for layer in isometric_map_layers: for layer in isometric_map_layers:
if is_instance_valid(layer): if is_instance_valid(layer):
layer.queue_free() layer.queue_free()
isometric_map_layers.clear() isometric_map_layers.clear()
# Create new layers for each height level # Create new layers for each height level
for z in GRID_SIZE_HEIGHT: for z in GRID_SIZE_HEIGHT:
var new_layer = TileMapLayer.new() var new_layer = TileMapLayer.new()
new_layer.set_name("IsometricMapLayer_" + str(z)) new_layer.set_name("IsometricMapLayer_" + str(z))
new_layer.tile_set = $TileMapLayer.tile_set # Set your tileset new_layer.tile_set = $TileMapLayer.tile_set # Set your tileset
new_layer.z_index = z # Set the z-index to match the layer's height new_layer.z_index = z # Set the z-index to match the layer's height
# Add other TileMap settings as needed
add_child(new_layer) add_child(new_layer)
isometric_map_layers.append(new_layer) isometric_map_layers.append(new_layer)
var debug_map = create_debug_map_array() var debug_map = create_debug_map_array()
# Draw the map # Draw the map
func draw_visible_tiles(): func draw_visible_tiles():
# clear all previously drawn tiles on each layer # clear all previously drawn tiles on each layer
for layer in isometric_map_layers: for layer in isometric_map_layers:
layer.clear() layer.clear()
# draw the map # draw the map
for z in GRID_SIZE_HEIGHT: for z in GRID_SIZE_HEIGHT:
for y in GRID_SIZE_LENGTH: for y in GRID_SIZE_LENGTH:
for x in GRID_SIZE_WIDTH: for x in GRID_SIZE_WIDTH:
var tile = debug_map[x][y][z] var tile = debug_map[x][y][z]
if tile != null and tile["visibility"]: if tile != null and tile["visibility"]:
# Use the layer that corresponds to the tile's z-value # Use the layer that corresponds to the tile's z-value
if z < isometric_map_layers.size(): if z < isometric_map_layers.size():
isometric_map_layers[z].set_cell( isometric_map_layers[z].set_cell(
Vector2i(tile["x"], tile["y"]), Vector2i(tile["x"], tile["y"]),
MAIN_SOURCE_ID, MAIN_SOURCE_ID,
tile["atlas_base_position"] tile["atlas_base_position"]
) )
var highlighted_tiles = {} # Dictionary to store all currently highlighted tiles var highlighted_tiles = {} # Dictionary to store all currently highlighted tiles
func isometric_grid_hover(): func isometric_grid_hover():
var hover_tile_position = isometric_map_layers[0].local_to_map(get_global_mouse_position()) var hover_tile_position = isometric_map_layers[0].local_to_map(get_global_mouse_position())
var new_highlighted_tiles = {} # Will store tiles to highlight this frame var new_highlighted_tiles = {} # Will store tiles to highlight this frame
# First find all tiles that should be highlighted # First find all tiles that should be highlighted
for z in GRID_SIZE_HEIGHT: for z in GRID_SIZE_HEIGHT:
for x in GRID_SIZE_WIDTH: for x in GRID_SIZE_WIDTH:
for y in GRID_SIZE_LENGTH: for y in GRID_SIZE_LENGTH:
var tile = debug_map[x][y][z] var tile = debug_map[x][y][z]
if tile != null and tile["visibility"]: if tile != null and tile["visibility"]:
if tile["x"] == hover_tile_position.x and tile["y"] == hover_tile_position.y: if tile["x"] == hover_tile_position.x and tile["y"] == hover_tile_position.y:
# Store this tile for highlighting # TODO: change highlighing so when the mouse is over an drawn tile and not the grid
var tile_key = str(x) + "_" + str(y) + "_" + str(z) var tile_above = isometric_map_layers[z+1].get_cell_source_id(
new_highlighted_tiles[tile_key] = { Vector2i(tile["x"]-1, tile["y"]-1)
"x": x, )
"y": y, # Store this tile for highlighting
"z": z var tile_key = str(x) + "_" + str(y) + "_" + str(z)
} # print(tile_above)
# print(tile["x"], " ", tile["y"], " ", z)
# print(hover_tile_position)
if not tile_above:
new_highlighted_tiles[tile_key] = {
"x": x,
"y": y,
"z": z+1
}
else:
new_highlighted_tiles[tile_key] = {
"x": x,
"y": y,
"z": z
}
# Highlight new tiles new_highlighted_tiles[tile_key] = {
for tile_key in new_highlighted_tiles: "x": x,
var tile_data = new_highlighted_tiles[tile_key] "y": y,
var tile = debug_map[tile_data.x][tile_data.y][tile_data.z] "z": z
}
if not tile["selected"]: # Highlight new tiles
isometric_map_layers[tile_data.z].set_cell( for tile_key in new_highlighted_tiles:
Vector2i(tile["x"], tile["y"]), var tile_data = new_highlighted_tiles[tile_key]
MAIN_SOURCE_ID, var tile = debug_map[tile_data.x][tile_data.y][tile_data.z]
tile["atlas_highlight_position"] if not tile["selected"]:
) isometric_map_layers[tile_data.z].set_cell(
else: Vector2i(tile["x"], tile["y"]),
isometric_map_layers[tile_data.z].set_cell( MAIN_SOURCE_ID,
Vector2i(tile["x"], tile["y"]), tile["atlas_highlight_position"]
1, )
Vector2i(3,1) # 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 tile["highlighted"] = true
for tile_key in highlighted_tiles:
if not (tile_key in new_highlighted_tiles):
var tile_data = highlighted_tiles[tile_key]
var tile = debug_map[tile_data.x][tile_data.y][tile_data.z]
if tile != null and tile["visibility"]: # 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 = debug_map[tile_data.x][tile_data.y][tile_data.z]
if not tile["selected"]: if tile != null and tile["visibility"]:
isometric_map_layers[tile_data.z].set_cell(
Vector2i(tile["x"], tile["y"]),
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 if not tile["selected"]:
highlighted_tiles = new_highlighted_tiles isometric_map_layers[tile_data.z].set_cell(
Vector2i(tile["x"], tile["y"]),
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
func _ready() -> void: func _ready() -> void:
# Store initial camera position # Store initial camera position
initial_camera_position = camera.position initial_camera_position = camera.position
initial_camera_zoom = camera.zoom initial_camera_zoom = camera.zoom
initialize_map_layers() initialize_map_layers()
draw_visible_tiles() draw_visible_tiles()
func _process(delta: float) -> void: func _process(_delta: float) -> void:
pass pass
# isometric_grid_hover() # isometric_grid_hover()
func _input(event): func _input(event):
if event is InputEventMouseMotion: if event is InputEventMouseMotion:
isometric_grid_hover() isometric_grid_hover()
# Camera drag (pan) control # Camera drag (pan) control
if event is InputEventMouseButton: if event is InputEventMouseButton:
if event.button_index == MOUSE_BUTTON_RIGHT: if event.button_index == MOUSE_BUTTON_RIGHT:
if event.pressed: if event.pressed:
drag_start = event.position drag_start = event.position
drag_active = true drag_active = true
else: else:
drag_active = false drag_active = false
# Zoom control with mouse wheel # Zoom control with mouse wheel
if event.button_index == MOUSE_BUTTON_WHEEL_DOWN: if event.button_index == MOUSE_BUTTON_WHEEL_DOWN:
zoom_camera(-zoom_speed) zoom_camera(-zoom_speed)
elif event.button_index == MOUSE_BUTTON_WHEEL_UP: elif event.button_index == MOUSE_BUTTON_WHEEL_UP:
zoom_camera(zoom_speed) zoom_camera(zoom_speed)
# Handle camera movement while dragging # Handle camera movement while dragging
if event is InputEventMouseMotion and drag_active: if event is InputEventMouseMotion and drag_active:
camera.position -= event.relative / camera.zoom camera.position -= event.relative / camera.zoom
func _on_reset_button_pressed() -> void: func _on_reset_button_pressed() -> void:
# Reset camera position and zoom # Reset camera position and zoom
debug_map = create_debug_map_array() debug_map = create_debug_map_array()
initialize_map_layers() initialize_map_layers()
draw_visible_tiles() draw_visible_tiles()
camera.position = initial_camera_position camera.position = initial_camera_position
camera.zoom = initial_camera_zoom camera.zoom = initial_camera_zoom
func zoom_camera(zoom_amount): func zoom_camera(zoom_amount):
var new_zoom = camera.zoom.x + zoom_amount var new_zoom = camera.zoom.x + zoom_amount
new_zoom = clamp(new_zoom, zoom_min, zoom_max) new_zoom = clamp(new_zoom, zoom_min, zoom_max)
camera.zoom = Vector2(new_zoom, new_zoom) camera.zoom = Vector2(new_zoom, new_zoom)
func _on_cw_pressed() -> void: func _on_cw_pressed() -> void:
_reset_class_values() _reset_class_values()
rotate_map_around_z_axis(3) rotate_map_around_z_axis(3)
initialize_map_layers() initialize_map_layers()
draw_visible_tiles() draw_visible_tiles()
func _on_ccw_pressed() -> void: func _on_ccw_pressed() -> void:
_reset_class_values() _reset_class_values()
rotate_map_around_z_axis(1) rotate_map_around_z_axis(1)
initialize_map_layers() initialize_map_layers()
draw_visible_tiles() draw_visible_tiles()
func _on_x_cw_pressed() -> void: func _on_x_cw_pressed() -> void:
_reset_class_values() _reset_class_values()
rotate_map_around_x_axis(1) rotate_map_around_x_axis(1)
initialize_map_layers() initialize_map_layers()
draw_visible_tiles() draw_visible_tiles()
func _on_x_ccw_pressed() -> void: func _on_x_ccw_pressed() -> void:
_reset_class_values() _reset_class_values()
rotate_map_around_x_axis(3) rotate_map_around_x_axis(3)
initialize_map_layers() initialize_map_layers()
draw_visible_tiles() draw_visible_tiles()
func _on_y_cw_pressed() -> void: func _on_y_cw_pressed() -> void:
_reset_class_values() _reset_class_values()
rotate_map_around_y_axis(3) rotate_map_around_y_axis(3)
initialize_map_layers() initialize_map_layers()
draw_visible_tiles() draw_visible_tiles()
func _on_y_ccw_pressed() -> void: func _on_y_ccw_pressed() -> void:
_reset_class_values() _reset_class_values()
rotate_map_around_y_axis(1) rotate_map_around_y_axis(1)
initialize_map_layers() initialize_map_layers()
draw_visible_tiles() draw_visible_tiles()
func _reset_class_values(): func _reset_class_values():
highlighted_tiles = {} highlighted_tiles = {}
last_click_time = 0.0 last_click_time = 0.0
clicked_position = Vector2i(1, 1) clicked_position = Vector2i(1, 1)
is_tile_selected = false is_tile_selected = false
var click_delay: float = 0.2 var click_delay: float = 0.2
var last_click_time: float = 0.0 var last_click_time: float = 0.0
var clicked_position: Vector2i = Vector2i(1, 1) var clicked_position: Vector2i = Vector2i(1, 1)
var is_tile_selected: bool = false var is_tile_selected: bool = false
func tile_selction_logic(position: Vector2i): func tile_selction_logic():
for z in GRID_SIZE_HEIGHT: for z in GRID_SIZE_HEIGHT:
for x in GRID_SIZE_WIDTH: for x in GRID_SIZE_WIDTH:
for y in GRID_SIZE_LENGTH: for y in GRID_SIZE_LENGTH:
var tile = debug_map[x][y][z] var tile = debug_map[x][y][z]
if tile["selected"] and tile["highlighted"]: if tile["selected"] and tile["highlighted"]:
isometric_map_layers[z].set_cell( isometric_map_layers[z].set_cell(
Vector2i(tile["x"], tile["y"]), Vector2i(tile["x"], tile["y"]),
1, 1,
Vector2i(0,1) # Vector2i(0,1) #
) )
tile["selected"] = false tile["selected"] = false
if tile["selected"] and not tile["highlighted"]: if tile["selected"] and not tile["highlighted"]:
isometric_map_layers[z].set_cell( isometric_map_layers[z].set_cell(
Vector2i(tile["x"], tile["y"]), Vector2i(tile["x"], tile["y"]),
0, 0,
Vector2i(0,0) # Vector2i(0,0) #
) )
tile["selected"] = false tile["selected"] = false
if not tile["selected"] and tile["highlighted"]: if not tile["selected"] and tile["highlighted"]:
isometric_map_layers[z].set_cell( isometric_map_layers[z].set_cell(
Vector2i(tile["x"], tile["y"]), Vector2i(tile["x"], tile["y"]),
1, 1,
Vector2i(3,1) # Vector2i(3,1) #
) )
tile["selected"] = true tile["selected"] = true
func _unhandled_input(event: InputEvent) -> void: func _unhandled_input(event: InputEvent) -> void:
if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT: if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
var current_time = Time.get_ticks_msec() / 1000.0 var current_time = Time.get_ticks_msec() / 1000.0
if current_time - last_click_time >= click_delay: if current_time - last_click_time >= click_delay:
last_click_time = current_time last_click_time = current_time
var new_clicked_position = isometric_map_layers[0].local_to_map(get_global_mouse_position()) tile_selction_logic()
tile_selction_logic(new_clicked_position) elif event is InputEventKey and event.pressed and event.keycode == KEY_ESCAPE:
elif event is InputEventKey and event.pressed and event.keycode == KEY_ESCAPE: pass
pass #deselect_tile()
#deselect_tile()

12
scripts/main_menu.gd
View File

@ -3,21 +3,21 @@ extends Control
# Called when the node enters the scene tree for the first time. # Called when the node enters the scene tree for the first time.
func _ready(): func _ready():
pass # Replace with function body. pass # Replace with function body.
# Called every frame. 'delta' is the elapsed time since the previous frame. # Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta): func _process(_delta):
pass pass
func _on_start_button_pressed(): func _on_start_button_pressed():
get_tree().change_scene_to_file("res://scenes/debug_level.tscn") get_tree().change_scene_to_file("res://scenes/debug_level.tscn")
func _on_option_button_pressed(): func _on_option_button_pressed():
get_tree().quit() get_tree().quit()
func _on_quit_button_pressed(): func _on_quit_button_pressed():
get_tree().quit() get_tree().quit()

6
scripts/player.gd
View File

@ -4,9 +4,9 @@ extends CharacterBody2D
@onready var animated_sprite: AnimatedSprite2D = $AnimatedSprite2D @onready var animated_sprite: AnimatedSprite2D = $AnimatedSprite2D
func _process(delta: float): func _process(_delta: float):
play_idle_animation() play_idle_animation()
func play_idle_animation(): func play_idle_animation():
animated_sprite.play("down") animated_sprite.play("down")