aboutsummaryrefslogtreecommitdiff
path: root/game/src/GameSession/MapView.gd
blob: 1b04097592f182d9a9e5b3c67667f53d08558467 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
extends Node3D

signal province_selected(index : int)
signal map_view_camera_changed(near_left : Vector2, far_left : Vector2, far_right : Vector2, near_right : Vector2)

const _action_north : StringName = &"map_north"
const _action_east : StringName = &"map_east"
const _action_south : StringName = &"map_south"
const _action_west : StringName = &"map_west"
const _action_zoom_in : StringName = &"map_zoom_in"
const _action_zoom_out : StringName = &"map_zoom_out"
const _action_drag : StringName = &"map_drag"
const _action_click : StringName = &"map_click"

const _shader_param_province_index : StringName = &"province_index_tex"
const _shader_param_province_index_subdivisions : StringName = &"province_index_subdivisions"
const _shader_param_province_colour : StringName = &"province_colour_tex"
const _shader_param_hover_index : StringName = &"hover_index"
const _shader_param_selected_index : StringName = &"selected_index"
const _shader_param_terrain_tile_factor : StringName = &"terrain_tile_factor"

@export var _camera : Camera3D

@export var _cardinal_move_speed : float = 1.0
@export var _edge_move_threshold: float = 0.01
@export var _edge_move_speed: float = 2.5
var _drag_anchor : Vector2
var _drag_active : bool = false

var _mouse_over_viewport : bool = true

@export var _zoom_target_min : float = 0.05
@export var _zoom_target_max : float = 5.0
@export var _zoom_target_step : float = 0.1
@export var _zoom_epsilon : float = _zoom_target_step * 0.1
@export var _zoom_speed : float = 5.0
@export var _zoom_target : float = 1.0:
   get: return _zoom_target
   set(v): _zoom_target = clamp(v, _zoom_target_min, _zoom_target_max)

@export var _map_mesh_instance : MeshInstance3D
var _map_mesh : MapMesh
var _map_shader_material : ShaderMaterial
var _map_image_size : Vector2
var _map_province_colour_image : Image
var _map_province_colour_texture : ImageTexture
var _map_mesh_corner : Vector2
var _map_mesh_dims : Vector2

var _mouse_pos_viewport : Vector2 = Vector2(0.5, 0.5)
var _mouse_pos_map : Vector2 = Vector2(0.5, 0.5)
var _viewport_dims : Vector2 = Vector2(1, 1)

# ??? Strange Godot/GDExtension Bug ???
# Upon first opening a clone of this repo with the Godot Editor,
# if GameSingleton.get_province_index_image is called before MapMesh
# is referenced in the script below, then the editor will crash due
# to a failed HashMap lookup. I'm not sure if this is a bug in the
# editor, GDExtension, my own extension, or a combination of them.
# This was an absolute pain to track down. --- hop311
func _ready():
   if _camera == null:
      push_error("MapView's _camera variable hasn't been set!")
      return
   _zoom_target = _camera.position.y
   if _map_mesh_instance == null:
      push_error("MapView's _map_mesh variable hasn't been set!")
      return

   # Shader Material
   var map_material := _map_mesh_instance.get_active_material(0)
   if map_material == null:
      push_error("Map mesh is missing material!")
      return
   if not map_material is ShaderMaterial:
      push_error("Invalid map mesh material class: ", map_material.get_class())
      return
   _map_shader_material = map_material

   # Province index textures
   var map_province_index_images := GameSingleton.get_province_index_images()
   if map_province_index_images == null or map_province_index_images.is_empty():
      push_error("Failed to get province index image!")
      return
   var province_index_texture := Texture2DArray.new()
   if province_index_texture.create_from_images(map_province_index_images) != OK:
      push_error("Failed to generate province index texture array!")
      return
   _map_shader_material.set_shader_parameter(_shader_param_province_index, province_index_texture)
   var subdivisions := GameSingleton.get_province_index_image_subdivisions()
   if subdivisions.x < 1 or subdivisions.y < 1:
      push_error("Invalid province index image subdivision: ", subdivisions.x, "x", subdivisions.y)
   _map_shader_material.set_shader_parameter(_shader_param_province_index_subdivisions, Vector2(subdivisions))

   # Province colour texture
   _map_province_colour_image = GameSingleton.get_province_colour_image()
   if _map_province_colour_image == null:
      push_error("Failed to get province colour image!")
      return
   _map_province_colour_texture = ImageTexture.create_from_image(_map_province_colour_image)
   _map_shader_material.set_shader_parameter(_shader_param_province_colour, _map_province_colour_texture)

   if not _map_mesh_instance.mesh is MapMesh:
      push_error("Invalid map mesh class: ", _map_mesh_instance.mesh.get_class(), "(expected MapMesh)")
      return
   _map_mesh = _map_mesh_instance.mesh

   # Set map mesh size and get bounds
   _map_image_size = Vector2(Vector2i(GameSingleton.get_width(), GameSingleton.get_height()))
   _map_mesh.aspect_ratio = _map_image_size.x / _map_image_size.y
   _map_shader_material.set_shader_parameter(_shader_param_terrain_tile_factor, _map_image_size.y / 64.0)
   var map_mesh_aabb := _map_mesh.get_core_aabb() * _map_mesh_instance.transform
   _map_mesh_corner = Vector2(
      min(map_mesh_aabb.position.x, map_mesh_aabb.end.x),
      min(map_mesh_aabb.position.z, map_mesh_aabb.end.z)
   )
   _map_mesh_dims = abs(Vector2(
      map_mesh_aabb.position.x - map_mesh_aabb.end.x,
      map_mesh_aabb.position.z - map_mesh_aabb.end.z
   ))

func _notification(what : int):
   match what:
      NOTIFICATION_WM_MOUSE_ENTER: # Mouse inside window
         _on_mouse_entered_viewport()
      NOTIFICATION_WM_MOUSE_EXIT: # Mouse out of window
         _on_mouse_exited_viewport()

func _update_colour_texture() -> void:
   GameSingleton.update_colour_image()
   _map_province_colour_texture.update(_map_province_colour_image)

func _world_to_map_coords(pos : Vector3) -> Vector2:
   return (Vector2(pos.x, pos.z) - _map_mesh_corner) / _map_mesh_dims

func _viewport_to_map_coords(pos_viewport : Vector2) -> Vector2:
   var ray_origin := _camera.project_ray_origin(pos_viewport)
   var ray_normal := _camera.project_ray_normal(pos_viewport)
   # Plane with normal (0,1,0) facing upwards, at a distance 0 from the origin
   var intersection = Plane(0, 1, 0, 0).intersects_ray(ray_origin, ray_normal)
   if typeof(intersection) == TYPE_VECTOR3:
      return _world_to_map_coords(intersection as Vector3)
   else:
      # Normals parallel to the xz-plane could cause null intersections,
      # but the camera's orientation should prevent such normals
      push_error("Invalid intersection: ", intersection)
      return Vector2(0.5, 0.5)

func zoom_in() -> void:
   _zoom_target -= _zoom_target_step

func zoom_out() -> void:
   _zoom_target += _zoom_target_step

# REQUIREMENTS
# * SS-31
func _unhandled_input(event : InputEvent):
   if _mouse_over_viewport and event.is_action_pressed(_action_click):
      # Check if the mouse is outside of bounds
      if _map_mesh.is_valid_uv_coord(_mouse_pos_map):
         var selected_index := GameSingleton.get_province_index_from_uv_coords(_mouse_pos_map)
         _map_shader_material.set_shader_parameter(_shader_param_selected_index, selected_index)
         province_selected.emit(selected_index)
      else:
         print("Clicked outside the map!")
   elif event.is_action_pressed(_action_drag):
      if _drag_active:
         push_warning("Drag being activated while already active!")
      _drag_active = true
      _drag_anchor = _mouse_pos_map
   elif event.is_action_released(_action_drag):
      if not _drag_active:
         push_warning("Drag being deactivated while already not active!")
      _drag_active = false
   elif event.is_action_pressed(_action_zoom_in, true):
      zoom_in()
   elif event.is_action_pressed(_action_zoom_out, true):
      zoom_out()

func _physics_process(delta : float):
   _mouse_pos_viewport = get_viewport().get_mouse_position()
   _viewport_dims = Vector2(Resolution.get_current_resolution())
   # Process movement
   _movement_process(delta)
   # Keep within map bounds
   _clamp_over_map()
   # Process zooming
   _zoom_process(delta)
   # Orient based on height
   _update_orientation()
   # Update viewport on minimap
   _update_minimap_viewport()
   # Calculate where the mouse lies on the map
   _update_mouse_map_position()

# REQUIREMENTS
# * UIFUN-124
func _movement_process(delta : float) -> void:
   var direction : Vector2
   if _drag_active:
      direction = (_drag_anchor - _mouse_pos_map) * _map_mesh_dims
   else:
      direction = _edge_scrolling_vector() + _cardinal_movement_vector()
      # Scale movement speed with height
      direction *= _camera.position.y * delta
   _camera.position += Vector3(direction.x, 0, direction.y)

# REQUIREMENTS
# * UIFUN-125
func _edge_scrolling_vector() -> Vector2:
   if not _mouse_over_viewport:
      return Vector2()
   var mouse_vector := _mouse_pos_viewport / _viewport_dims - Vector2(0.5, 0.5)
   if abs(mouse_vector.x) < 0.5 - _edge_move_threshold and abs(mouse_vector.y) < 0.5 - _edge_move_threshold:
      mouse_vector *= 0
   return mouse_vector * _edge_move_speed

# REQUIREMENTS
# * SS-75
func _cardinal_movement_vector() -> Vector2:
   var move := Vector2(
      float(Input.is_action_pressed(_action_east)) - float(Input.is_action_pressed(_action_west)),
      float(Input.is_action_pressed(_action_south)) - float(Input.is_action_pressed(_action_north))
   )
   return move * _cardinal_move_speed

func _clamp_over_map() -> void:
   _camera.position.x = _map_mesh_corner.x + fposmod(_camera.position.x - _map_mesh_corner.x, _map_mesh_dims.x)
   _camera.position.z = clamp(_camera.position.z, _map_mesh_corner.y, _map_mesh_corner.y + _map_mesh_dims.y)

# REQUIREMENTS
# * SS-74
# * UIFUN-123
func _zoom_process(delta : float) -> void:
   var height := _camera.position.y
   var zoom := _zoom_target - height
   height += zoom * _zoom_speed * delta
   var new_zoom := _zoom_target - height
   # Set to target if height is within _zoom_epsilon of it or has overshot past it
   if abs(new_zoom) < _zoom_epsilon or sign(zoom) != sign(new_zoom):
      height = _zoom_target
   _camera.position.y = height

func _update_orientation() -> void:
   var dir := Vector3(0, -1, -exp(-_camera.position.y - 1))
   _camera.look_at(_camera.position + dir)

func _update_minimap_viewport() -> void:
   var near_left := _viewport_to_map_coords(Vector2(0, _viewport_dims.y))
   var far_left := _viewport_to_map_coords(Vector2(0, 0))
   var far_right := _viewport_to_map_coords(Vector2(_viewport_dims.x, 0))
   var near_right := _viewport_to_map_coords(_viewport_dims)
   map_view_camera_changed.emit(near_left, far_left, far_right, near_right)

func _update_mouse_map_position() -> void:
   _mouse_pos_map = _viewport_to_map_coords(_mouse_pos_viewport)
   var hover_index := GameSingleton.get_province_index_from_uv_coords(_mouse_pos_map)
   if _mouse_over_viewport:
      _map_shader_material.set_shader_parameter(_shader_param_hover_index, hover_index)

func _on_mouse_entered_viewport():
   _mouse_over_viewport = true

func _on_mouse_exited_viewport():
   _mouse_over_viewport = false

func _on_minimap_clicked(pos_clicked : Vector2):
   pos_clicked *= _map_mesh_dims
   _camera.position.x = pos_clicked.x
   _camera.position.z = pos_clicked.y
   _clamp_over_map()

func enable_processing() -> void:
   set_process_unhandled_input(true)
   set_physics_process(true)

func disable_processing() -> void:
   set_process_unhandled_input(false)
   set_physics_process(false)