How can I align my troops on a battle screen? - 2d

Question

I'm trying to recreate Stickwar's flash game, a game in which I'm a big fan of but got suck when I attempt to align my troops. Particularly, here is the in game views of it:
As you can see, the are many stickmans who align next to each other. A horizon line is consist of five stickmans. If there is another stickman, it will automatically aligns on the next line and so on.
These Stickmans, however, do not always function like that. The stickman with archer's class will always stay behind all of the troops, while the guy with spear are always if in the front of the troops as leader. If the leader was spawn but the first line is full, then the other troops will automatically move back, leaving the first line empty, which is the same with the second lines and so on.
I have no idea how to build this up in Godot. So if there are anybody who have some hints, please let me know. I really appreciate all the efforts. This doesn't seems like a good question to ask but I honestly can't find any Godot tutorials related to it, so I'm really sorry if this question is bother you. (also sorry for my bad grammars, too)

Answer 1

And don't expect to find tutorials for everything. How does people who make the tutorials figure out things in the first place? What you need is to break this down into smaller problems that are addressable.
I'll figure it out as I write.
One part is that you need to have units that can move to a particular location. Which could be to attack an enemy, or, yes, to their spot in the formation.
Another is that you need to define the possible spot where the units can stand in formation.
And the last is that you need code that tells the units to which spot they should go. This code would make sure to not send multiple units to the same spot, and to follow whatever rules for the formations you have.
Given the game, I'm going to use Area2D for the units.
Why?
I'm not using Sprite or something graphic directly because they must be clickable by the player.
I'm not using KinematicBody2D nor RigidBody2D because I don't see the collide with each other.
And I'm not using StaticBody2D because they need to move freely.
So Area2D it is.
Now, these Area2D will be given a target to go to. We can use a Vector2 for that:
extends Area2D
export var target:Vector2
Let us make sure that the target matches their position when they are ready (And I remind you that Vector2.ZERO is a valid position):
extends Area2D
export var target:Vector2
func _ready() -> void:
target = global_position
I'm working with global coordinates because I don't want to have to convert to local coordinates of the unit when I write the code that will set these positions.
I remind you that the local space of different nodes is different.
Now, we need it to move towards that target. So we write _physics_process. Let us start with direction and distance:
extends Area2D
export var target:Vector2
func _ready() -> void:
target = global_position
func _physics_process(delta:float) -> void:
var direction := global_position.direction_to(target)
var distance := global_position.distance_to(target)
For reference, I could have also done it like this:
extends Area2D
export var target:Vector2
func _ready() -> void:
target = global_position
func _physics_process(delta:float) -> void:
var displacement := target - global_position
var direction := displacement.normalized()
var distance := displacement.length()
And let us figure out how much we can move per physics frame. Which also means I need to define a speed:
extends Area2D
export var target:Vector2
export var speed:float = 100.0
func _ready() -> void:
target = global_position
func _physics_process(delta:float) -> void:
var direction := global_position.direction_to(target)
var distance := global_position.distance_to(target)
var max_distance := speed * delta
Ok, I'm setting the speed to 100.0 because - given that we are working in 2D - it will be in pixels per second. And if it is something too small you are not going to see it. However, tweak the value to your needs.
And for the distance we can move in the current physics frame I'm multiplying speed by delta. Remember that delta is the elapsed time since the last frame, and also remember that speed is distance divided by time. So when we multiply the speed by time, the time cancels out and we have distance.
Now, we don't want to overshoot the target, so we are going to clamp the distance:
extends Area2D
export var target:Vector2
export var speed:float = 100.0
func _ready() -> void:
target = global_position
func _physics_process(delta:float) -> void:
var direction := global_position.direction_to(target)
var distance := min(global_position.distance_to(target), speed * delta)
And we need to move, of course:
extends Area2D
export var target:Vector2
export var speed:float = 100.0
func _ready() -> void:
target = global_position
func _physics_process(delta:float) -> void:
var direction := global_position.direction_to(target)
var distance := min(global_position.distance_to(target), speed * delta)
global_position += direction * distance
Just for reference I'll write the code for KinematicBody2D using move_and_slide:
extends KinematicBody2D
export var target:Vector2
export var speed:float = 100.0
func _ready() -> void:
target = global_position
func _physics_process(delta:float) -> void:
var direction := global_position.direction_to(target)
var distance := global_position.distance_to(target)
var velocity = direction * min(distance / delta, speed)
move_and_slide(velocity)
Again, speed is distance divided by time. And velocity is speed with a direction. I hope this makes sense.
We would also need to trigger animations and flip the sprite (which would be a child node) if necessary.
Something like this:
$AnimatedSprite.flip_h = direction.x < 0
if distance.is_equal_approx(Vector2.ZERO):
$AnimatedSprite.play("idle")
else:
$AnimatedSprite.play("walk")
About defining the posible spots, we could use Position2D. Perhaps group them as necessary.
However, as I'll describe below, we can use Path2D.
And to assign the targets...
We are going to start from the front line and move backwards. We are going to need to have the units in buckets, and exhaust the buckets in order.
Ok, there are multiple kinds of units. You can make an scene for each kind of unit, they can all use the script for motion that I have above. You can then also go ahead an set different node groups to them, so we can get them with get_tree().get_nodes_in_group.
Now, we have different rules for how each group uses each line. If I understand correctly, the leader will be alone on its line, soldiers will be in groups of 5, and archers will be all in the same line.
Thus, it would be useful to define the lines as... lines. I would say Line2D but that is graphical and we don't want these visible. So, instead we will use Path2D, which also has some convenient methods to find equally spaced points over them.
For convenience, let us make the Path2D children of the node where we will be assigning targets. So we can get them like this:
var paths:Array = get_children()
We also need the list of groups, for example:
var groups = ["Leader", "Soldier", "Archer"]
And the number of them we can group… Let us make a class (I suggest to put this at the end of the file).
class Group:
var name:String
var max_count:float
func _init(name:String, max_count:float):
self.name = name
self.max_count = max_count
Now the list of groups:
var groups = [
Group.new("Leader", 1),
Group.new("Soldier", 5),
Group.new("Archer", INF)
]
And we will be working down these in order:
var paths:Array = get_children()
for item in groups:
var group := item as Group
var units_in_group := get_tree().get_nodes_in_group(group.name)
if units_in_group.empty():
continue
var path := paths.pop_back()
var count := min(units_in_group.size(), group.max_count)
# figure out the positions
Ok, now I have another issue. I have a range from 0 to 1 to divide by n elements. When I have one element I want to get the position at the middle (0.5), but if I say 1/n when n is 1 I get 1 not 0.5.
So, 1/n will be the separation between elements. But I need to offset the position by half that.
I think I got it (I'm writing here, not testing it):
var paths:Array = get_children()
for item in groups:
var group := item as Group
var units_in_group := get_tree().get_nodes_in_group(group.name)
if units_in_group.empty():
continue
var path := paths.pop_back() as Path2D
var count := min(units_in_group.size(), group.max_count)
var separation := 1.0/count
var offset := separation * 0.5
for index in count:
var position := path.interpolatef(index * separation + offset)
# assign the position
I must be getting the position in the local space of the path. Under that assumption, I'll convert them to global before passing them to the unit.
var paths:Array = get_children()
for item in groups:
var group := item as Group
var units_in_group := get_tree().get_nodes_in_group(group.name)
if units_in_group.empty():
continue
var path := paths.pop_back() as Path2D
var count := min(units_in_group.size(), group.max_count)
var separation := 1.0/count
var offset := separation * 0.5
for index in count:
var unit := units_in_group[index]
var position := path.to_global(
path.interpolatef(
index * separation + offset
)
)
unit.target = position
Ah, but wait, we need to continue assigning units from the same group on the next path…
Let us start by erasing from units_in_group the units we have already assigned a target to, so we don't repeat. Which also means we cannot get them by index. So I will use pop_back instead:
var paths:Array = get_children()
for item in groups:
var group := item as Group
var units_in_group := get_tree().get_nodes_in_group(group.name)
if units_in_group.empty():
continue
var path := paths.pop_back() as Path2D
var count := min(units_in_group.size(), group.max_count)
var separation := 1.0/count
var offset := separation * 0.5
for index in count:
var unit := units_in_group.pop_back()
var position := path.to_global(
path.interpolatef(
index * separation + offset
)
)
unit.target = position
And now we can loop until it is empty:
var paths:Array = get_children()
for item in groups:
var group := item as Group
var units_in_group := get_tree().get_nodes_in_group(group.name)
while not units_in_group.empty():
var path := paths.pop_back() as Path2D
var count := min(units_in_group.size(), group.max_count)
var separation := 1.0/count
var offset := separation * 0.5
for index in count:
var unit := units_in_group.pop_back()
var position := path.to_global(
path.interpolatef(
index * separation + offset
)
)
unit.target = position
And I think that should work.
Perhaps we could do better… In particular, I would rather this assigned the unit that is nearest to the position we want.
We can find the best unit like this:
var position := path.to_global(
path.interpolatef(
index * separation + offset
)
)
var best_distance := INF
var best_unit:Node2D = null
for unit in units_in_group:
var c_unit := unit as Node2D
var c_distance := c_unit.global_position.distance_to(position)
if c_distance < best_distance:
best_distance = c_distance
best_unit = c_unit
Here c_ stands for current. I would normally write it down fully, but I opted for this to not make the lines too long.
Since we are going to be picking this way, we cannot simply pop_back from units_in_group. Instead we will erase the one we picked.
var paths:Array = get_children()
for item in groups:
var group := item as Group
var units_in_group := get_tree().get_nodes_in_group(group.name)
while not units_in_group.empty():
var path := paths.pop_back() as Path2D
var count := min(units_in_group.size(), group.max_count)
var separation := 1.0/count
var offset := separation * 0.5
for index in count:
var position := path.to_global(
path.interpolatef(
index * separation + offset
)
)
var best_distance := INF
var best_unit:Node2D = null
for unit in units_in_group:
var c_unit := unit as Node2D
var c_distance := c_unit.global_position.distance_to(position)
if c_distance < best_distance:
best_distance = c_distance
best_unit = c_unit
units_in_group.erase(best_unit)
best_unit.target = position
I'm tempted to refactor the selection of the best unit to a separate function. I submit it to your consideration.
Finally, thinking about the failure modes of this code: What comes to mind is that there might not be enough paths to position all the units. You can prevent that by setting a maximum number of units… Or you could write code to create paths as needed.
Hopefully I addressed everything that needed to be addressed.