Collision Avoidance

Game Mechanics
#1

Now this might be a piece of cake to most of you, but it took me several attempts to create a satisfying result regarding this.
Since I didn’t find much regarding Collision Avoidance on the internet, I thought I post my function here. For two reasons!

Reason number 1, I have a feeling I am overcomplicating this and it could be done with much fewer lines of code. I know … I shouldn’t
even worry about that because my function does work perfectly fine (it seems). But yeah, I’m still very curious. I commented the code
for easier readability, please take a look!

Reason number 2, if my approach to Collision Avoidance does get your seal of approval I thought this might help others that struggle with it, since I
didn’t find much resources on that topic out there.

Thank you!

EDIT: The code is intented for a topdown 2D game in which you can move in all four directions (up, down, left, right).

	public void move(float dx, float dy, Array<Entity> obstacles){
		
		setBodyPos(x + dx, y + dy);	// Set Body(Rectangle) to where it will be if dx/dy get applied
		updateBodyCenter();
		
		SortedIntList<Entity> overlappingObs = new SortedIntList<Entity>();
		float distX, distY;
		int distDirect;
		
		for(Entity obs : obstacles){	// Loop through all available Obstacles
	
			if(body.overlaps(obs.body)){	// Check if intersection with the Object is true
				obs.updateBodyCenter();
				distX = (centerX) - (obs.centerX);
				distY = (centerY) - (obs.centerY);
				distDirect = (int)(Math.pow(distX, 2) + Math.pow(distY, 2));	// Calculate the distance between this
																						// Entity and the Obstacle
				int index = distDirect;
				boolean tryIndex = true;
				
				do{											// Do-While loop to avoid double indexes (Took me hours to find that error)
					if(overlappingObs.get(index) == null){	
						overlappingObs.insert(index, obs);	// Add the intersecting Obstacles to a List
						tryIndex = false;					// (Sorted from closest to farthest Obstacle)
					}
					else{
						index++;
					}
				}while(tryIndex);
			}
		}
		
		Iterator<SortedIntList.Node<Entity>> iterator = overlappingObs.iterator();

		while (iterator.hasNext()) {	// Loop through the sorted intersecting Obstacles
			SortedIntList.Node<Entity> node = iterator.next();
			Entity obs = node.value;

			if(body.overlaps(obs.body)){
				float xOffset = 0, yOffset = 0;	// Calculate how much of the Obstacle's body intersects
					
				if(centerX > obs.centerX) xOffset = body.x - (obs.body.x + obs.body.width);
				if(centerX <= obs.centerX) xOffset = (body.x + body.width) - obs.body.x;
				
				if(centerY > obs.centerY) yOffset = body.y - (obs.body.y + obs.body.height);
				if(centerY <= obs.centerY) yOffset = (body.y + body.height) - obs.body.y;
				
				if(Math.abs(yOffset) > Math.abs(xOffset)){	// Substract the calculated offsets from the dx, dy values
					dx -= xOffset;
				}
				else if(Math.abs(xOffset) > Math.abs(yOffset)){
					dy -= yOffset;
				}
				
				setBodyPos(x + dx, y + dy);	// Update the Entity's body to be on the newly calculated position
				updateBodyCenter();
			}
		}

		x += dx;
		y += dy;
		
		overlappingObs.clear();
		overlappingObs = null;
		iterator = null;
	}