713 lines
20 KiB
GDScript
713 lines
20 KiB
GDScript
extends Node2D
|
|
|
|
|
|
onready var Grid = get_node("Grid")
|
|
onready var GridHighlight = get_node("GridHighlight")
|
|
onready var Editor = get_node("../Editor")
|
|
|
|
onready var Islands = get_node("Islands")
|
|
onready var DigSites = get_node("DigSites")
|
|
onready var EditIslandButton = get_node("UI/DebugContainer/EditIslandButton")
|
|
onready var WorldCamera = get_node("Camera")
|
|
onready var OffsetValueLabel = get_node("UI/DebugContainer/OffsetValue")
|
|
onready var ZoomValueLabel = get_node("UI/DebugContainer/ZoomValue")
|
|
onready var HexCoordValueLabel = get_node("UI/DebugContainer/HexCoordValue")
|
|
onready var WorldCoordValueLabel = get_node("UI/DebugContainer/WorldCoordValue")
|
|
onready var TileTypeValueLabel = get_node("UI/DebugContainer/TileTypeValue")
|
|
onready var RepeatButton = get_node("UI/HBoxContainer/RepeatButton")
|
|
onready var SuccessMessage = get_node("UI/SuccessMessage")
|
|
onready var PlayerChar = get_node("PlayerChar")
|
|
onready var PlayerBoat = get_node("PlayerBoat")
|
|
onready var FPSValueLabel = get_node("UI/DebugContainer/FPSValue")
|
|
|
|
onready var IslandMap = get_node("UI/IslandMap")
|
|
onready var IslandMapRenderer = get_node("../IslandMapRenderer")
|
|
|
|
onready var MapButton = get_node("UI/VBoxContainer/MapButton")
|
|
onready var BirdyButton = get_node("UI/VBoxContainer/BirdyButton")
|
|
onready var DigButton = get_node("UI/VBoxContainer/DigButton")
|
|
|
|
onready var BirdyTimer = get_node("Birdy/Timer")
|
|
onready var MapTimer = get_node("UI/IslandMap/Timer")
|
|
|
|
var Island = preload("Island.gd")
|
|
var SpringDamper = preload("res://SpringDamper.gd")
|
|
|
|
var DigSiteSprite = preload("res://assets/digsite.svg")
|
|
var DigSiteTreasureSprite = preload("res://assets/treasuredigsite.svg")
|
|
|
|
var hex_grid_bbox = [[0,0], [10,10]]
|
|
|
|
var hex_hover = Vector2.ZERO
|
|
var is_dragging = false
|
|
var drag_start = null
|
|
var target = Vector2()
|
|
var tile_data = {}
|
|
var current_island = null
|
|
var anchor_tile = null
|
|
var landing_tile = null
|
|
var player_navigation_path = []
|
|
var player_path_plan_start = null
|
|
var player_path_plan_end = null
|
|
var hex_line_path = []
|
|
var treasure_island = null
|
|
var treasure_map_rendered = false
|
|
var bird_flying = false
|
|
|
|
var birdy_spring = null
|
|
var birdy_spring_x = Vector2.ONE
|
|
var birdy_spring_v = Vector2.ZERO
|
|
var birdy_spring_xt = Vector2.ONE * Globals.zoom_sailing
|
|
var birdy_duration = 4.0
|
|
|
|
var map_duration = 4.0
|
|
|
|
signal digging_started
|
|
signal world_generation_triggered
|
|
signal wrong_digsite
|
|
signal treasure_found
|
|
signal bird_flight_start
|
|
signal bird_flight_end
|
|
signal map_opened
|
|
signal map_closed
|
|
signal level_started
|
|
|
|
#
|
|
# Godot Functions
|
|
#
|
|
func _ready():
|
|
Grid.view_camera = WorldCamera
|
|
GridHighlight.view_camera = WorldCamera
|
|
|
|
birdy_spring = SpringDamper.new(2, 0.99, 0.5)
|
|
|
|
generate()
|
|
|
|
# Set player starting position
|
|
PlayerChar.position = Globals.HexGrid.get_hex_center(Vector2(0,0))
|
|
PlayerChar.connect("dig_stopped", self, "on_dig_stopped")
|
|
|
|
self.connect("treasure_found", self, "on_treasure_found")
|
|
self.connect("bird_flight_start", self, "on_bird_flight_started")
|
|
self.connect("bird_flight_end", self, "on_bird_flight_ended")
|
|
|
|
self.connect("map_opened", self, "on_map_opened")
|
|
self.connect("map_closed", self, "on_map_closed")
|
|
|
|
# We're starting on the water
|
|
DigButton.disabled = true
|
|
|
|
func _process(delta):
|
|
if is_editor_active():
|
|
WorldCamera.offset = PlayerChar.position
|
|
WorldCamera.zoom = birdy_spring_x
|
|
|
|
if len(player_navigation_path) > 1:
|
|
var player_coord = Globals.WorldToHexCenter(PlayerChar.transform.origin)
|
|
if (player_coord - player_navigation_path[0]).length_squared() < 0.1:
|
|
player_navigation_path.remove(0)
|
|
|
|
if len(player_navigation_path) > 0:
|
|
PlayerChar.target = player_navigation_path[0]
|
|
|
|
update_current_island()
|
|
|
|
if current_island:
|
|
PlayerBoat.transform.origin = Globals.HexToWorld(anchor_tile)
|
|
else:
|
|
PlayerBoat.transform.origin = PlayerChar.transform.origin
|
|
|
|
var res = birdy_spring.calc(birdy_spring_x, birdy_spring_v, birdy_spring_xt, delta)
|
|
birdy_spring_x = res[0]
|
|
birdy_spring_v = res[1]
|
|
|
|
if BirdyTimer.time_left == 0:
|
|
birdy_spring_xt = Vector2.ONE * Globals.zoom_sailing
|
|
|
|
if birdy_spring_x.x > Globals.zoom_sailing * 1.2:
|
|
if bird_flying == false:
|
|
bird_flying = true
|
|
emit_signal("bird_flight_start")
|
|
elif birdy_spring_x.x < Globals.zoom_sailing * 1.1:
|
|
if bird_flying == true:
|
|
bird_flying = false
|
|
emit_signal("bird_flight_end")
|
|
|
|
if MapTimer.time_left == 0:
|
|
emit_signal("map_closed")
|
|
|
|
|
|
func draw_hex_path (path: Array, color: Color):
|
|
var path_len = len(path)
|
|
if path_len > 0:
|
|
var last_point = path[0]
|
|
draw_circle(last_point, 5, color)
|
|
for i in range (1, path_len):
|
|
var cur_point = path[i]
|
|
draw_line (last_point, cur_point, color)
|
|
draw_circle(cur_point, 5, color)
|
|
last_point = cur_point
|
|
|
|
|
|
func _draw():
|
|
if Globals.debug_nav:
|
|
draw_hex_path (hex_line_path, "#00f2f2")
|
|
draw_hex_path (player_navigation_path, "#f200f2")
|
|
|
|
if player_path_plan_start != null and player_path_plan_end != null:
|
|
draw_circle (player_path_plan_start, 12, "#2288f2")
|
|
draw_circle (player_path_plan_end, 12, "#2288f2")
|
|
|
|
var obstacles = []
|
|
if current_island != null:
|
|
obstacles = Globals.IslandNavGrid.get_obstacles()
|
|
else:
|
|
obstacles = Globals.OceanNavGrid.get_obstacles()
|
|
|
|
for coords in obstacles:
|
|
draw_set_transform(Globals.HexToWorld(coords), 0, Vector2.ONE)
|
|
draw_polygon(HexTileDrawer.HexPoints, HexTileDrawer.create_color_array("#929"))
|
|
|
|
|
|
#
|
|
# World Modification/Query
|
|
#
|
|
func clear_islands():
|
|
for island in Islands.get_children():
|
|
Islands.remove_child(island)
|
|
island.queue_free()
|
|
|
|
|
|
func clear_digsites():
|
|
for digsite in DigSites.get_children():
|
|
DigSites.remove_child(digsite)
|
|
digsite.queue_free()
|
|
|
|
|
|
func get_tile_type(world_coord: Vector2):
|
|
for island in Islands.get_children():
|
|
var tile = island.get_tile_by_world_coord(world_coord)
|
|
if tile != null:
|
|
return tile
|
|
|
|
return null
|
|
|
|
|
|
func add_island_at(file_name, offset_world: Vector2):
|
|
var island = Island.new()
|
|
island.load_island(file_name)
|
|
island.set_offset_world(offset_world)
|
|
Islands.add_child(island)
|
|
|
|
|
|
func is_editor_active():
|
|
return Editor == null or not Editor.is_active()
|
|
|
|
|
|
func check_player_on_treasure():
|
|
if current_island == null:
|
|
return false
|
|
|
|
return current_island.is_point_on_treasure_site(Globals.HexToWorld(PlayerChar.cur_tile))
|
|
|
|
|
|
func check_island_location_valid(new_island):
|
|
var grid_origin_world_coord = Globals.HexToWorld(Vector2(0,0))
|
|
if new_island.get_tile_by_world_coord(grid_origin_world_coord) != null:
|
|
return false
|
|
|
|
var islands = Islands.get_children()
|
|
for island in islands:
|
|
if island.check_overlap(new_island):
|
|
return false
|
|
|
|
return true
|
|
|
|
|
|
func place_treasure():
|
|
assert (treasure_island != null)
|
|
var island_tile_coords = treasure_island.tiles.keys()
|
|
var grass_tiles = []
|
|
for coord in island_tile_coords:
|
|
if treasure_island.tiles[coord] == "Grass":
|
|
grass_tiles.append(coord)
|
|
|
|
treasure_island.treasure_local_coords = grass_tiles[randi() % len(grass_tiles)]
|
|
|
|
if Globals.debug_nav:
|
|
treasure_island.highlight_treasure = true
|
|
|
|
treasure_island.update()
|
|
|
|
|
|
func prerender_island(island):
|
|
var render_island = Island.new()
|
|
render_island.tiles = island.tiles.duplicate()
|
|
render_island.treasure_local_coords = island.treasure_local_coords
|
|
render_island.name = "island"
|
|
render_island.prerender = true
|
|
|
|
var island_rect_local_center = island.rect_local.position + 0.5 * island.rect_local.size
|
|
|
|
var viewport = Viewport.new()
|
|
viewport.size = island.rect_local.size
|
|
viewport.own_world = true
|
|
viewport.global_canvas_transform.origin = -island_rect_local_center
|
|
add_child(viewport)
|
|
|
|
var camera = Camera2D.new()
|
|
viewport.add_child(camera)
|
|
viewport.add_child(render_island)
|
|
camera.make_current()
|
|
viewport.render_target_v_flip = true
|
|
viewport.render_target_update_mode = Viewport.UPDATE_ONCE
|
|
|
|
yield(get_tree(), "idle_frame")
|
|
yield(get_tree(), "idle_frame")
|
|
|
|
var img_tex = ImageTexture.new()
|
|
img_tex.create_from_image(viewport.get_texture().get_data(), 0)
|
|
island.render_sprite.texture = img_tex
|
|
island.render_sprite.centered = false
|
|
island.render_sprite.transform.origin = island.rect_world.position
|
|
|
|
for c in viewport.get_children():
|
|
viewport.remove_child(c)
|
|
c.queue_free()
|
|
|
|
remove_child(viewport)
|
|
viewport.queue_free()
|
|
viewport = null
|
|
|
|
island.update()
|
|
|
|
|
|
func render_treasure_map():
|
|
IslandMapRenderer.render_target_update_mode = Viewport.UPDATE_ONCE
|
|
IslandMapRenderer.render_target_clear_mode = Viewport.CLEAR_MODE_ONLY_NEXT_FRAME
|
|
var camera = IslandMapRenderer.get_node("Camera2D")
|
|
camera.current = true
|
|
camera.zoom = Vector2.ONE * 10.0
|
|
camera.offset = treasure_island.center_world_coord
|
|
var island = Island.new()
|
|
island.tiles = treasure_island.tiles.duplicate()
|
|
island.treasure_local_coords = treasure_island.treasure_local_coords
|
|
island.highlight_treasure = true
|
|
island.name = "island"
|
|
|
|
for child in IslandMapRenderer.get_children():
|
|
if child.name == "island":
|
|
print ("removing ", child)
|
|
IslandMapRenderer.remove_child(child)
|
|
child.queue_free()
|
|
break
|
|
|
|
IslandMapRenderer.add_child(island)
|
|
|
|
IslandMap.texture = IslandMapRenderer.get_texture()
|
|
|
|
|
|
func reset():
|
|
PlayerChar.transform.origin = Vector2.ZERO
|
|
PlayerChar.position = Vector2.ZERO
|
|
PlayerChar.target = Vector2.ZERO
|
|
|
|
hex_line_path = []
|
|
player_navigation_path = []
|
|
player_path_plan_start = null
|
|
player_path_plan_end = null
|
|
|
|
current_island = null
|
|
treasure_island = null
|
|
|
|
clear_islands()
|
|
clear_digsites()
|
|
|
|
SuccessMessage.visible = false
|
|
|
|
|
|
func generate():
|
|
reset()
|
|
|
|
var rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
randomize()
|
|
|
|
var radius = 800
|
|
var num_islands = Globals.game_num_islands
|
|
|
|
var island_files = []
|
|
for i in range (10):
|
|
island_files.append("res://islands/pirate_game_island_" + str(i) + ".island")
|
|
island_files.shuffle()
|
|
|
|
for i in range (num_islands):
|
|
var island = Island.new()
|
|
var file_name = island_files[i]
|
|
island.load_island(file_name)
|
|
|
|
var rand_coord = Vector2(rng.randi_range(-radius, radius), rng.randi_range(-radius, radius))
|
|
island.set_offset_world(Globals.WorldToHexCenter(rand_coord))
|
|
|
|
var location_valid = check_island_location_valid(island)
|
|
var overlap_retry_num = 0
|
|
var overlap_retry_max = 10
|
|
while !location_valid and overlap_retry_num < overlap_retry_max:
|
|
if overlap_retry_num % 4 == 0:
|
|
radius = radius + 200
|
|
overlap_retry_num = overlap_retry_num + 1
|
|
|
|
rand_coord = Vector2(rng.randi_range(-radius, radius), rng.randi_range(-radius, radius))
|
|
island.set_offset_world(Globals.WorldToHexCenter(rand_coord))
|
|
location_valid = check_island_location_valid(island)
|
|
|
|
if !location_valid:
|
|
print ("Could not place island! steps: " + str(overlap_retry_num))
|
|
else:
|
|
print ("Placed after " + str(overlap_retry_num) + " retries.")
|
|
# prerender_island(island)
|
|
Islands.add_child(island)
|
|
|
|
num_islands = Islands.get_child_count()
|
|
treasure_island = Islands.get_child(rng.randi() % num_islands)
|
|
|
|
place_treasure()
|
|
|
|
render_treasure_map()
|
|
|
|
populate_ocean_nav_grid()
|
|
|
|
emit_signal("level_started")
|
|
|
|
#
|
|
# Navigation
|
|
#
|
|
func populate_ocean_nav_grid():
|
|
var obstacles = Globals.OceanNavGrid.get_obstacles()
|
|
Globals.OceanNavGrid.remove_obstacles(obstacles.keys())
|
|
Globals.OceanNavGrid.set_bounds(Vector2.ONE * -500, Vector2.ONE * 500)
|
|
|
|
for island in Islands.get_children():
|
|
for tile in island.tiles.keys():
|
|
var grid_coords = Globals.WorldToHex(tile + island.offset_world)
|
|
Globals.OceanNavGrid.add_obstacles(grid_coords, 0)
|
|
|
|
|
|
func populate_island_nav_grid():
|
|
var obstacles = Globals.IslandNavGrid.get_obstacles()
|
|
Globals.IslandNavGrid.remove_obstacles(obstacles.keys())
|
|
Globals.IslandNavGrid.set_bounds(Vector2.ONE * -500, Vector2.ONE * 500)
|
|
|
|
if current_island == null:
|
|
print ("Error: cannot populate island nav grid: no island")
|
|
return
|
|
|
|
var landing_site_coords = Globals.WorldToHex(current_island.landing_site_world)
|
|
for tile in current_island.obstacles_local_coords.keys():
|
|
var grid_coords = Globals.WorldToHex(tile + current_island.offset_world)
|
|
|
|
# Allow navigation to the anchor tile
|
|
if (grid_coords - anchor_tile).length() < 0.1:
|
|
continue
|
|
|
|
Globals.IslandNavGrid.add_obstacles(grid_coords, 0)
|
|
|
|
|
|
func update_current_island():
|
|
var islands = Islands.get_children()
|
|
|
|
var last_current_island = current_island
|
|
current_island = null
|
|
for island in islands:
|
|
if island.get_tile_by_world_coord(PlayerChar.position) != null:
|
|
current_island = island
|
|
break
|
|
|
|
if last_current_island != current_island:
|
|
if last_current_island != null:
|
|
on_leave_island(last_current_island)
|
|
|
|
if current_island != null:
|
|
on_enter_island(current_island)
|
|
|
|
|
|
func on_enter_island(island):
|
|
print ("Entering island")
|
|
PlayerChar.on_enter_island()
|
|
current_island = island
|
|
anchor_tile = PlayerChar.prev_tile
|
|
landing_tile = PlayerChar.cur_tile
|
|
island.landing_site_world = Globals.WorldToHexCenter(PlayerChar.position)
|
|
island.landing_site_local_coord = island.get_local_coord_by_world_coord(PlayerChar.position)
|
|
island.is_active = true
|
|
populate_island_nav_grid()
|
|
island.update()
|
|
|
|
DigButton.disabled = false
|
|
|
|
if Globals.debug_nav:
|
|
update()
|
|
|
|
|
|
func on_leave_island(island):
|
|
print ("Leaving island")
|
|
PlayerChar.on_leave_island()
|
|
island.is_active = false
|
|
island.landing_site_local_coord = null
|
|
island.update()
|
|
|
|
DigButton.disabled = true
|
|
|
|
if Globals.debug_nav:
|
|
update()
|
|
|
|
|
|
func on_dig_stopped():
|
|
print ("Dig stopped!")
|
|
var dig_site = Sprite.new()
|
|
dig_site.transform.origin = Globals.HexToWorld(PlayerChar.cur_tile)
|
|
|
|
if check_player_on_treasure():
|
|
emit_signal("treasure_found")
|
|
on_treasure_found()
|
|
dig_site.texture = DigSiteTreasureSprite
|
|
else:
|
|
emit_signal("wrong_digsite")
|
|
dig_site.texture = DigSiteSprite
|
|
|
|
DigSites.add_child(dig_site)
|
|
|
|
|
|
func on_treasure_found():
|
|
RepeatButton.disabled = false
|
|
pass
|
|
|
|
|
|
func on_map_opened():
|
|
BirdyButton.disabled = true
|
|
IslandMap.visible = true
|
|
MapTimer.one_shot = true
|
|
MapTimer.start(map_duration)
|
|
|
|
|
|
func on_map_closed():
|
|
BirdyButton.disabled = false
|
|
IslandMap.visible = false
|
|
|
|
|
|
func on_bird_flight_started():
|
|
print ("flight started")
|
|
MapButton.disabled = true
|
|
|
|
|
|
func on_bird_flight_ended():
|
|
print ("flight ended")
|
|
MapButton.disabled = false
|
|
|
|
|
|
func check_player_near_anchor():
|
|
if current_island == null:
|
|
return false
|
|
|
|
var anchor_world = Globals.HexToWorld(anchor_tile)
|
|
return (PlayerChar.position - anchor_world).length() < Globals.hex_size
|
|
|
|
|
|
func update_navigation_target_ocean(start_world: Vector2, target_world: Vector2):
|
|
var start_coord = Globals.WorldToHex(start_world)
|
|
var goal_coord = Globals.WorldToHex(target_world)
|
|
var island_landing_site_world = null
|
|
|
|
player_path_plan_start = null
|
|
player_path_plan_end = null
|
|
|
|
var direct_path = Globals.WorldLineToHexTiles(start_world, target_world)
|
|
|
|
if get_tile_type(start_world) != null and current_island != null and len(direct_path) > 1:
|
|
# print ("on landing site: ", current_island.is_point_on_landing_site (start_world))
|
|
if current_island.is_point_on_landing_site (start_world):
|
|
if get_tile_type(direct_path[1]) == null:
|
|
# print ("starting from landing site")
|
|
direct_path.pop_front()
|
|
start_coord = Globals.WorldToHex(direct_path.front())
|
|
else:
|
|
print ("Invalid start")
|
|
return
|
|
|
|
# In case target is on an island we find both a landing site and
|
|
# the first point on the ocean that we can reach.
|
|
if get_tile_type(target_world) != null:
|
|
var last_removed = null
|
|
while len(direct_path) > 0 and get_tile_type(direct_path.back()) != null:
|
|
last_removed = direct_path.back()
|
|
direct_path.pop_back()
|
|
|
|
if len(direct_path) == 0:
|
|
print ("Could not find path!")
|
|
return
|
|
|
|
# print ("Using ", Globals.WorldToHex(direct_path.back()), " instead of ", goal_coord, " as goal.")
|
|
goal_coord = Globals.WorldToHex(direct_path.back())
|
|
island_landing_site_world = last_removed
|
|
|
|
player_path_plan_start = Globals.HexToWorld(start_coord)
|
|
player_path_plan_end = Globals.HexToWorld(goal_coord)
|
|
|
|
var path = Globals.OceanNavGrid.find_path(start_coord, goal_coord)
|
|
for target in path.slice(0,-1):
|
|
var target_world_coord = Globals.HexToWorld(target.axial_coords)
|
|
var target_type = get_tile_type(target_world_coord)
|
|
|
|
player_navigation_path.append(target_world_coord)
|
|
|
|
if target_type == "Sand":
|
|
break
|
|
|
|
if island_landing_site_world != null:
|
|
player_navigation_path.append(island_landing_site_world)
|
|
|
|
if len(player_navigation_path) > 0:
|
|
PlayerChar.target = player_navigation_path[0]
|
|
|
|
|
|
func update_navigation_target_island(start_world: Vector2, target_world: Vector2):
|
|
var start_coord = Globals.WorldToHex(start_world)
|
|
var goal_coord = Globals.WorldToHex(target_world)
|
|
|
|
var path = Globals.IslandNavGrid.find_path(start_coord, goal_coord)
|
|
for target in path.slice(0,-1):
|
|
var target_world_coord = Globals.HexToWorld(target.axial_coords)
|
|
var target_type = get_tile_type(target_world_coord)
|
|
|
|
player_navigation_path.append(target_world_coord)
|
|
|
|
|
|
func update_player_navigation_target(target_world: Vector2):
|
|
var start_world = PlayerChar.transform.origin
|
|
|
|
player_navigation_path = []
|
|
|
|
var start_timestamp = OS.get_system_time_msecs()
|
|
|
|
var player_near_anchor = check_player_near_anchor()
|
|
|
|
if current_island != null:
|
|
update_navigation_target_island(start_world, target_world)
|
|
|
|
if len(player_navigation_path) == 0 and player_near_anchor:
|
|
start_world = Globals.HexToWorld(anchor_tile)
|
|
|
|
if current_island == null or (len(player_navigation_path) == 0 and player_near_anchor):
|
|
update_navigation_target_ocean(start_world, target_world)
|
|
|
|
var planning_duration_msec = OS.get_system_time_msecs() - start_timestamp
|
|
|
|
if Globals.debug_nav:
|
|
update()
|
|
|
|
#
|
|
# Input & Events
|
|
#
|
|
|
|
func handle_game_event(event):
|
|
if Editor and Editor.is_active():
|
|
return false
|
|
|
|
if bird_flying:
|
|
return false
|
|
|
|
if event is InputEventMouseButton:
|
|
# Move main character
|
|
if event.pressed and event.button_index == BUTTON_LEFT:
|
|
update_player_navigation_target (Globals.HexGrid.get_hex_center(Globals.ScreenToHex(event.position, WorldCamera)))
|
|
|
|
return false
|
|
|
|
|
|
func update_hex_line_path(target: Vector2):
|
|
var start = PlayerChar.position
|
|
|
|
hex_line_path = Globals.WorldLineToHexTiles(start, target)
|
|
|
|
|
|
func _unhandled_input(event):
|
|
if event is InputEventMouseButton:
|
|
if handle_game_event(event):
|
|
return
|
|
|
|
# Move camera
|
|
if event.pressed and event.button_index == 2:
|
|
is_dragging = true
|
|
drag_start = (WorldCamera.offset / WorldCamera.zoom.x + event.position)
|
|
else:
|
|
is_dragging = false
|
|
|
|
# Zoom Camera
|
|
if event.pressed and event.button_index == BUTTON_WHEEL_DOWN and event.pressed and WorldCamera.zoom.y < 5.5:
|
|
WorldCamera.zoom = WorldCamera.zoom * 1.0 / 0.8
|
|
elif event.button_index == BUTTON_WHEEL_UP and event.pressed:
|
|
WorldCamera.zoom = WorldCamera.zoom * 0.8
|
|
|
|
if 'position' in event:
|
|
hex_hover = Globals.ScreenToHex(event.position, WorldCamera)
|
|
GridHighlight.pos = hex_hover
|
|
HexCoordValueLabel.text = str(hex_hover)
|
|
var world_coord = Globals.ScreenToWorld(event.position, WorldCamera)
|
|
var tile_type = get_tile_type(world_coord)
|
|
if tile_type != null:
|
|
TileTypeValueLabel.text = tile_type
|
|
else:
|
|
TileTypeValueLabel.text = "None"
|
|
|
|
WorldCoordValueLabel.text = str(world_coord)
|
|
|
|
update_hex_line_path(world_coord)
|
|
|
|
if is_dragging:
|
|
WorldCamera.offset = (drag_start - event.position) * WorldCamera.zoom.x
|
|
|
|
|
|
OffsetValueLabel.text = str(WorldCamera.offset)
|
|
ZoomValueLabel.text = str(WorldCamera.zoom)
|
|
|
|
|
|
func _on_MapButton_pressed():
|
|
if IslandMap.visible:
|
|
emit_signal("map_closed")
|
|
else:
|
|
emit_signal("map_opened")
|
|
|
|
|
|
func _on_BirdyButton_pressed():
|
|
if birdy_spring_xt == Vector2.ONE * Globals.zoom_sailing:
|
|
birdy_spring_xt = Vector2.ONE * Globals.zoom_birdy
|
|
BirdyTimer.one_shot = true
|
|
BirdyTimer.start(birdy_duration)
|
|
else:
|
|
BirdyTimer.stop()
|
|
birdy_spring_xt = Vector2.ONE * Globals.zoom_sailing
|
|
|
|
|
|
func _on_DigButton_pressed():
|
|
print ("dig pressed")
|
|
if PlayerChar.state == PlayerChar.State.Walking:
|
|
emit_signal("digging_started")
|
|
PlayerChar.on_dig_start()
|
|
|
|
|
|
func _on_IslandMap_visibility_changed():
|
|
if IslandMap.visible:
|
|
emit_signal("map_opened")
|
|
else:
|
|
emit_signal("map_closed")
|
|
|
|
|
|
func _on_GenerateButton_pressed():
|
|
emit_signal("world_generation_triggered")
|
|
RepeatButton.disabled = true
|
|
generate()
|
|
|
|
func _on_BackButton_pressed():
|
|
get_tree().change_scene("res://Menu.tscn")
|
|
|