refactor: rename directions not to use abbreviations

Author: NathanLovato

src/common/directions.gd

@@ -2,32 +2,28 @@
 class_name Directions
 extends RefCounted
 
-## Abbreviations for 8 cardinal points (i.e. NW = Northwest, or Vector2[-1, -1]).
-enum Points { NW, N, NE, E, SE, S, SW, W }
+## The cardinal points, in clockwise order starting from North.
+enum Points { NORTH, EAST, SOUTH, WEST }
 
-## The [Vector2i] form of a given cardinal point. That is, North is Vector2i(0, -1), etc.
+## The direction corresponding to a cardinal point as a [Vector2i] value. NORTH is Vector2i(0, -1), etc.
 const MAPPINGS: = {
-	#Directions.Points.NW: Vector2i(-1, -1),
-	Directions.Points.N: Vector2i.UP,
-	#Directions.Points.NE: Vector2i(1, -1),
-	Directions.Points.E: Vector2i.RIGHT,
-	#Directions.Points.SE: Vector2i(1, 1),
-	Directions.Points.S: Vector2i.DOWN,
-	#Directions.Points.SW: Vector2i(-1, 1),
-	Directions.Points.W: Vector2i.LEFT,
+	Directions.Points.NORTH: Vector2i.UP,
+	Directions.Points.EAST: Vector2i.RIGHT,
+	Directions.Points.SOUTH: Vector2i.DOWN,
+	Directions.Points.WEST: Vector2i.LEFT,
 }
 
 
 ## Convert an angle, such as from [method Vector2.angle], to a [constant Points].
 static func angle_to_direction(angle: float) -> Points:
-	if angle <= -PI/4 and angle > -3*PI/4:
-		return Points.N
-	elif angle <= PI/4 and angle > -PI/4:
-		return Points.E
-	elif angle <= 3*PI/4 and angle > PI/4:
-		return Points.S
-	
-	return Points.W
+	if angle <= -PI / 4.0 and angle > -3.0 * PI / 4.0:
+		return Points.NORTH
+	elif angle <= PI / 4.0 and angle > -PI / 4.0:
+		return Points.EAST
+	elif angle <= 3.0 * PI / 4.0 and angle > PI / 4.0:
+		return Points.SOUTH
+
+	return Points.WEST
 
 
 static func vector_to_direction(vector: Vector2) -> Points:

src/field/gamepieces/animation/gamepiece_animation.gd

@@ -1,101 +1,110 @@
 @tool
 ## Encapsulates [Gamepiece] animation as an optional component.
 ##
-## Allows [method play]ing animations that automatically adapt to the parent [Gamepiece]'s
-## direction. Transitions between animations are handled automatically, including changes to
-## direction.
-## [br][br][b]Note:[/b] This is usually not added to the scene tree directly by the designer.
+## Allows playing animations that automatically adapt to the parent
+## [Gamepiece]'s direction by calling [method play]. Transitions between
+## animations are handled automatically, including changes to direction.
+## [br][br][b]Note:[/b] This is usually not added to the scene tree directly by
+## the designer.
+##
 ## Rather, it is typically added to a [Gamepiece] through the [member Gamepiece.animation_scene]
 ## property.
 @icon("res://assets/editor/icons/GamepieceAnimation.svg")
 class_name GamepieceAnimation extends Marker2D
 
-## Name of the animation sequence used to reset animation properties to default. Note that this
-## animation is only played for a single frame during animation transitions.
+## Name of the animation sequence used to reset animation properties to default.
+## Note that this animation is only played for a single frame during animation
+## transitions.
 const RESET_SEQUENCE_KEY: = "RESET"
 
 ## Mapping that pairs cardinal [constant Directions.Points] with a [String] suffix.
 const DIRECTION_SUFFIXES: = {
-	Directions.Points.N: "_n",
-	Directions.Points.E: "_e",
-	Directions.Points.S: "_s",
-	Directions.Points.W: "_w",
+	Directions.Points.NORTH: "_n",
+	Directions.Points.EAST: "_e",
+	Directions.Points.SOUTH: "_s",
+	Directions.Points.WEST: "_w",
 }
 
 ## The animation currently being played.
 var current_sequence_id: = "":
 	set = play
 
 ## The direction faced by the gamepiece.
-## [br][br]Animations may optionally be direction-based. Setting the direction will use directional 
-## animations if they are available; otherwise non-directional animations will be used.
-var direction: = Directions.Points.S:
+##
+## Animations may optionally be direction-based. Setting the direction will use
+## directional animations if they are available; otherwise non-directional
+## animations will be used.
+var direction: = Directions.Points.SOUTH:
 	set = set_direction
 
 @onready var _anim: = $AnimationPlayer as AnimationPlayer
 
 
 ## Change the currently playing animation to a new value, if it exists.
-## [br][br]Animations may be added with or without a directional suffix (i.e. _n for north/up).
-## Directional animations will be preferred with direction-less animations as a fallback.
+##
+## Animations may be added with or without a directional suffix (i.e. _n for
+## north/up). Directional animations will be preferred with direction-less
+## animations as a fallback.
 func play(value: String) -> void:
 	if value == current_sequence_id:
 		return
-	
+
 	if not is_inside_tree():
 		await ready
-	
-	# We need to check to see if the animation is valid.
-	# First of all, look for a directional equivalent - e.g. idle_n. If that fails, look for 
-	# the new sequence id itself.
+
+	# We need to check to see if the animation is valid. First of all, look for
+	# a directional equivalent - e.g. idle_n. If that fails, look for the new
+	# sequence id itself.
 	var sequence_suffix: String = DIRECTION_SUFFIXES.get(direction, "")
 	if _anim.has_animation(value + sequence_suffix):
 		current_sequence_id = value
 		_swap_animation(value + sequence_suffix, false)
-	
+
 	elif _anim.has_animation(value):
 		current_sequence_id = value
 		_swap_animation(value, false)
 
 
 ## Change the animation's direction.
-## If the currently running animation has a directional variant matching the new direction it will
-## be played. Otherwise the direction-less animation will play.
+##
+## If the currently running animation has a directional variant matching the new
+## direction it will be played. Otherwise the direction-less animation will
+## play.
 func set_direction(value: Directions.Points) -> void:
 	if value == direction:
 		return
-	
+
 	direction = value
-	
+
 	if not is_inside_tree():
 		await ready
-	
+
 	var sequence_suffix: String = DIRECTION_SUFFIXES.get(direction, "")
 	if _anim.has_animation(current_sequence_id + sequence_suffix):
 		_swap_animation(current_sequence_id + sequence_suffix, true)
-	
+
 	elif _anim.has_animation(current_sequence_id):
 		_swap_animation(current_sequence_id, true)
 
 
-# Transition to the next animation sequence, accounting for the RESET track and current animation
-# elapsed time.
+## Transition to the next animation sequence, accounting for the RESET track and
+## current animation elapsed time.
 func _swap_animation(next_sequence: String, keep_position: bool) -> void:
 	var next_anim = _anim.get_animation(next_sequence)
-	
+
 	if next_anim:
 		# If keeping the current position, we want to do so as a ratio of the
 		# position / animation length to account for animations of different length.
 		var current_position_ratio = 0
 		if keep_position:
 			current_position_ratio = \
 				_anim.current_animation_position / _anim.current_animation_length
-		
+
 		# RESET the animation immediately to its default reset state before the next sequence.
 		# Take advantage of the default RESET animation to clear uncommon changes (i.e. flip_h).
 		if _anim.has_animation(RESET_SEQUENCE_KEY):
 			_anim.play(RESET_SEQUENCE_KEY)
 			_anim.advance(0)
-		
+
 		_anim.play(next_sequence)
 		_anim.advance(current_position_ratio * next_anim.length)

src/field/gamepieces/gamepiece.gd

@@ -30,14 +30,14 @@ signal direction_changed(new_direction: Directions.Points)
 @export var animation_scene: PackedScene:
 	set(value):
 		animation_scene = value
-		
+
 		if not is_inside_tree():
 			await ready
-		
+
 		if animation:
 			animation.queue_free()
 			animation = null
-		
+
 		if animation_scene:
 			# Check to make sure that the supplied scene instantiates as a GamepieceAnimation.
 			var new_scene: = animation_scene.instantiate()
@@ -48,7 +48,7 @@ signal direction_changed(new_direction: Directions.Points)
 				new_scene.free()
 				animation_scene = null
 				return
-			
+
 			follower.add_child(animation)
 
 ## The gamepiece will traverse a movement path at [code]move_speed[/code] pixels per second.
@@ -64,14 +64,14 @@ var animation: GamepieceAnimation = null
 ## The [code]direction[/code] is a unit vector that points where the gamepiece is 'looking'.
 ## In the event that the gamepiece is moving along a path, direction is updated automatically as
 ## long as the gamepiece continues to move.
-var direction: = Directions.Points.S:
+var direction: = Directions.Points.SOUTH:
 	set(value):
 		if value != direction:
 			direction = value
-			
+
 			if not is_inside_tree():
 				await ready
-			
+
 			animation.direction = direction
 			direction_changed.emit(direction)
 
@@ -87,33 +87,33 @@ var rest_position: = Vector2.ZERO
 var destination: Vector2
 
 ## Node2Ds may want to follow the gamepiece's animation, rather than position (which updates only at
-## the end of a path). Nodes may follow a travelling gamepiece by receiving the path follower's 
+## the end of a path). Nodes may follow a travelling gamepiece by receiving the path follower's
 ## transform.[/br][/br]
 ## The [member RemoteTransform2D.remote_path] is reserved for the player camera, but other nodes
 ## may access the anchor's position directly.
 @onready var animation_transform: = $PathFollow2D/CameraAnchor as RemoteTransform2D
 
 # The following objects allow the gamepiece to appear to move smoothly around the gameboard.
 # Please note that the path is decoupled from the gamepiece's position (scale is set to match
-# the gamepiece in _ready(), however) in order to simplify path management. All path coordinates may 
-# be provided in game-world coordinates and will remain relative to the origin even as the 
+# the gamepiece in _ready(), however) in order to simplify path management. All path coordinates may
+# be provided in game-world coordinates and will remain relative to the origin even as the
 # gamepiece's position changes.
 @onready var follower: = $PathFollow2D as PathFollow2D
 
 
 func _ready() -> void:
 	set_process(false)
-	
+
 	if not Engine.is_editor_hint() and is_inside_tree():
 		# Some gamepieces may be added to the scene before the Gameboard properties are set. In that
 		# case, wait for Gameboard dimensions to be set before registering the gamepiece.
 		if Gameboard.properties == null:
 			await Gameboard.properties_set
-		
+
 		# Snap the gamepiece to the cell on which it is standing.
 		var cell: = Gameboard.get_cell_under_node(self)
 		position = Gameboard.cell_to_pixel(cell)
-		
+
 		# Then register the gamepiece with the registry. Note that if a gamepiece already exists at
 		# the cell, this one will simply be freed.
 		if GamepieceRegistry.register(self, cell) == false:
@@ -123,27 +123,27 @@ func _ready() -> void:
 func _process(delta: float) -> void:
 	# How far will the gamepiece move this frame?
 	var move_distance: = move_speed * delta
-	
+
 	# We need to let others know that the gamepiece will arrive at the end of its path THIS frame.
 	# A controller may want to extend the path (for example, if a move key is held down or if
 	# another waypoint should be added to the move path).
 	# If we do NOT do so and the path is extended post arrival, there will be a single frame where
-	# the gamepiece's velocity is discontinuous (drops, then increases again), causing jittery 
+	# the gamepiece's velocity is discontinuous (drops, then increases again), causing jittery
 	# movement.
 	# The excess travel distance allows us to know how much to extend the path by. A VERY fast
 	# gamepiece may jump a few cells at a time.
 	var excess_travel_distance: =  follower.progress + move_distance - curve.get_baked_length()
 	if excess_travel_distance >= 0.0:
 		arriving.emit(excess_travel_distance)
-	
+
 	# The path may have been extended, so the gamepiece can move along the path now.
 	follower.progress += move_distance
-	
+
 	# Figure out which direction the gamepiece is facing, making sure that the GamepieceAnimation
 	# scene doesn't rotate.
 	animation.global_rotation = 0
 	direction = Directions.angle_to_direction(follower.rotation)
-	
+
 	# If the gamepiece has arrived, update it's position and movement details.
 	if follower.progress >= curve.get_baked_length():
 		stop()
@@ -155,16 +155,16 @@ func _process(delta: float) -> void:
 ## Note that the Gamepiece's position will remain fixed until it has fully traveresed its movement
 ## path. At this point, its position is then updated to its destination.
 func move_to(target_point: Vector2) -> void:
-	# Note that the destination is where the gamepiece will end up in game world coordinates. 
+	# Note that the destination is where the gamepiece will end up in game world coordinates.
 	destination = target_point
 	set_process(true)
-	
+
 	if curve == null:
 		curve = Curve2D.new()
 		curve.add_point(Vector2.ZERO)
-		
+
 		animation.play("run")
-	
+
 	# The positions on the path, however, are all relative to the gamepiece's current position. The
 	# position doesn't update until the Gamepiece reaches its final destination, otherwise the path
 	# would move along with the gamepiece.
@@ -178,11 +178,11 @@ func stop() -> void:
 	follower.progress = 0
 	curve = null
 	destination = Vector2.ZERO
-	
+
 	# Handle the change to animation.
 	animation.global_rotation = 0
 	animation.play("idle")
-	
+
 	# Stop movement and update logic.
 	set_process(false)
 	arrived.emit()