Having an issue blocking UI taps from passing through the UI into a gameobject.

UI elements are GameObjects as well. So IsPointerOverGameObject() will return true even for UI elements. Switch to using a Physics2D.Raycast. The origin point will be your tap location on the screen (Use a ScreenToWorld call), and the direction will be into the scene (most likely forward, not sure with 2D games). Tag the environment as "Ground" and when you Raycast against it, check the tag for Ground, then move if it is. If you need help writing the code, reply back here.

Sorry, had work come up.

Actually, you don't have to use a direct Raycast call after all. Here's what you do:

• Make sure you have an EventSystem somewhere in your scene (search for it)

• If you don't, highlight your scene in the Hierarchy, right click, GameObject > UI > EventSystem

• Add a Physics2DRaycaster to your scene camera (should be your MainCamera)

• Create the GroundMove script below

• Highlight all ground objects in your scene

• Click the Add Component button in the inspector and search for GroundMove

• Double Click the script

• Make sure to overwrite your PlayerTest file with the one I provided

  ---

You'll need to overwrite your PlayerTest file with the following:

 using UnityEngine;

 public class PlayerTest : MonoBehaviour {
     public Animator animator;
     public bool     needToMove;
     public float    timeMoveNeeded;
     public Vector2  direction = new Vector2();
     public Vector2  position = new Vector2();
     public Vector2  movement = new Vector2();
     public Vector2  target   = new Vector2();
     Rigidbody2D rb2D;
     public float speed = 2.0f;
     
     void Start() {
         animator = gameObject.GetComponent<Animator>();   
         rb2D = GetComponent<Rigidbody2D>();
 
         foreach (GroundMove gm in FindObjectsOfType<GroundMove>())
             gm.RaiseGroundClicked += HandleGroundClicked;
     }
 
     void FixedUpdate() {
         if (needToMove)
             transform.position = Vector2.Lerp(transform.position, target, speed * Time.fixedDeltaTime);
 
         if ((target - (Vector2)transform.position).magnitude <= 0.1f)
             needToMove = false;
     }
 
     void HandleGroundClicked(object sender, Vector2EventArgs e)
     {
         target = e.Data;
 
         if ((target - position).magnitude >= 0.1)
         {
             needToMove = true;
             direction  = (target - position).normalized;
 
             movement.x = (direction.x * speed * Time.deltaTime);
             movement.y = (direction.y * speed * Time.deltaTime);
 
             animator.SetBool("isMoving", true);
             animator.SetFloat("moveX", direction.x);
             animator.SetFloat("moveY", direction.y);
         }
     }
 }

 using UnityEngine;
 using UnityEngine.EventSystems;
 using System;
 public class GroundMove : MonoBehaviour, IPointerDownHandler {
     public event EventHandler<Vector2EventArgs> RaiseGroundClicked;
     public void OnPointerDown(PointerEventData data)
     {
         OnRaiseGroundClicked(new Vector2EventArgs(data.pointerCurrentRaycast.worldPosition));
     }
 
     protected virtual void OnRaiseGroundClicked(Vector2EventArgs e)
     {
         EventHandler<Vector2EventArgs> handler = RaiseGroundClicked;
 
         if (handler != null)
             handler(this, e);
     }
 }
 
 public class Vector2EventArgs : EventArgs {
     Vector2 m_data;
 
     public Vector2EventArgs(Vector2 data)
     {
         m_data = data;
     }
 
     public Vector2 Data { get { return m_data; } }
 }

Ok, what's all that do?

Basically, I don't know how many ground objects you have, so I made an event handler with a custom event argument type. When you click any ground objects, you use the IPointerDown event (provided by the EventSystem in Unity) to raise a custom event (GroundMove.RaiseGroundClicked) which reports the world location of the point that was clicked. The player object continually listens for any data to come up from these scripts (the event registration in PlayerTest.Start When data appears (the event is being handled) the player reacts to the click by beginning to move. It obviates the need for FixedUpdate in this case, so rather than checking each frame to see whether the user has interacted with the game, the player object is happy to sit there until the user actually does something. Neat, huh?

EDIT Switched to a Lerp. Setting velocity directly on rigidbodies I think isn't correct practice - need to look into it. I think correct practice is to use the AddForce methods, but I'm not terribly sure. The new code in PlayerTest gets you moving.

You could also make a layermask for the UI elements and when using RayCastHit pass in the layermask to check against eg: RaycastHit(start vector*the point of origin for the click*, out ray*the ray that is being cast*, layermask) and it will only return the gameobjects hit on that layer. Then you simply need to set the layer of the UI elements to match that of the layer mask you declared. For more info on this I would recommend watching: this