Simulate walking with collisions In this challenge, the task is to write a program or function which simulates a number of people walking. Input will be some representation of the people's positions on a 2d grid, and one of four directions (or none) for each.
The movement follows a few rules:

No person can walk into a space occupied by a person who is not moving
No two or more people can walk into the same space (none of them move)
No two adjacent people can swap positions

If a person would not collide with another, they will move one space in the specified direction. You can choose how directions are represented. All coordinates are pairs of integers. No two people will start in the same position.
Test cases:
Inputs are represented as pairs of coordinates ([x, y]), followed by a direction. Outputs are only the resulting coordinates. All of these have four people for simplicity, but inputs can consist of any (non-zero) number of people.
Input 1:
[[[0, 0], +y], [[-1, 0], +x], [[-2, 0], +x], [[1, 0], -x]]

Output 1:
[[0, 1], [-1, 0], [-2, 0], [1, 0]]

Input 2:
[[[0, 0], none], [[0, 1], +y], [[0, 2], +y], [[0, 3], +x]]

Output 2:
[[0, 0], [0, 2], [0, 3], [1, 3]]

Input 3:
[[[0, -1], +y], [[0, -2], +y], [[0, -3], +y], [[1, -2], -x]]

Output 3:
[[0, 0], [0, -1], [0, -3], [1, -2]]

Input 4:
[[[0, 0] +x], [[1, 0], +y], [[1, 1], -x], [[0, 1], -y], [[2, 0], +x]]

Output 4:
[[1, 0], [1, 1], [0, 1], [0, 0], [3, 0]]

Input 5:
[[[0, 0] +x], [[1, 0], +y], [[1, 1], -x], [[0, 1], -y], [[2, 0], -x]]

Output 5:
[[0, 0], [1, 0], [1, 1], [0, 1], [2, 0]]

Input 6:
[[[0, 1], -y], [[1, 1], -x], [[1, 0], +y], [[0, 0] +x], [[2, 0], +x]]

Output 6:
[[0, 0], [0, 1], [1, 1], [1, 0], [3, 0]]

This is code-golf, shortest answer in bytes per language wins!
J, 60 58 50 47 bytes
[:+/(*1,:1-(1&lt;1#.+/=/+/)+{.(~:*[=i.{_,~])+/)^:_

Try it online!
Takes input as a matrix of complex numbers -- starting positions in the 1st row, steps to walk in the 2nd row.
Passes all test cases including those suggested by tsh and the cycle of 4 suggested by xnor.
tldr how
We iteratively adjust the steps to be 0 for impossible moves (same destination (1&lt;1#.+/=/+/) or + swaps {.(~:*[=i.{_,~])+/) until they reach a fixed point ^:_.  Iteration is needed because some steps only become illegal after a walker changes from someone who will move to someone standing still.  There's a chain reaction.
After that iteration, impossible steps will have been converted to 0, and legal steps will remain what they were.
Once that's done, we just add those steps to the starting positions [:+/.