MapTest

小地图

using UnityEngine;

public class MoveCtr : MonoBehaviour
{
    float hor, ver;
    bool isMove = false;
    Vector3 targetPos;
    public Vector3 dir;
    public float moveSpeed = 3f;
    public float rotateSpeed = 15f;

    private void Awake()
    {
        EventCenter.AddListener<Vector3>(EventType.MoveTarget, MoveTarget);
    }

    private void Update()
    {
        hor = Input.GetAxis("Horizontal");
        ver = Input.GetAxis("Vertical");
        if(hor != 0 || ver != 0)
        {
            if (isMove)
            {
                isMove = false;
                EventCenter.Broadcast<bool>(EventType.FlagState, false);
            } 
            dir = new Vector3(hor, 0, ver);
            Move(dir);
            EventCenter.Broadcast(EventType.UpdateMap);
        }
        if (isMove)
        {
            dir = targetPos - transform.position;
            Move(dir);
            if (Vector3.Distance(transform.position, targetPos) < 0.2f)
            {
                transform.position = targetPos;
                isMove = false;
                targetPos = Vector3.zero;
                EventCenter.Broadcast<bool>(EventType.FlagState, false);
            }
            EventCenter.Broadcast(EventType.UpdateMap);
        }
    }

    private void Move(Vector3 tmpDir)
    {
        transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.LookRotation(tmpDir), rotateSpeed * Time.deltaTime);
        transform.Translate(Vector3.forward * Time.deltaTime * moveSpeed);
    }

    private void MoveTarget(Vector3 pos)
    {
        isMove = true;
        targetPos = pos;
    }

    private void OnDestroy()
    {
        EventCenter.RemoveListener<Vector3>(EventType.MoveTarget, MoveTarget);
    }

mapCtr

using UnityEngine;
using UnityEngine.EventSystems;

public class MapCtr : MonoBehaviour, IPointerClickHandler
{
    Vector2 mapSize;
    Vector2 min, max;
    Bounds bounds;
    float x, y;
    RectTransform pointRectTra;
    RectTransform flagRectTra;
    
    public GameObject player;
    public Transform treeain;
    public GameObject flag;

    private void Awake()
    {
        pointRectTra = transform.GetChild(0) as RectTransform;
        mapSize = transform.GetComponent<RectTransform>().sizeDelta;
        bounds = treeain.GetComponent<Renderer>().bounds;
        flagRectTra = flag.GetComponent<RectTransform>();
        FlagState(false);
        EventCenter.AddListener(EventType.UpdateMap, UpdateMapPoint);
        EventCenter.AddListener<bool>(EventType.FlagState, FlagState);
    }

    private void Update()
    {
#if UNITY_EDITOR


#endif
    }

    private void UpdateMapPoint()
    {
        x = (player.transform.position.x - bounds.min.x) / bounds.size.x;
        y = (player.transform.position.z - bounds.min.z) / bounds.size.z;

        pointRectTra.anchoredPosition = new Vector2(mapSize.x * x, mapSize.y * y);
        pointRectTra.rotation = Quaternion.Euler(0, 0, -player.transform.eulerAngles.y);
    }

    public void OnPointerClick(PointerEventData eventData)
    {
        if (!flag.activeSelf) FlagState(true); 
        flag.transform.position = eventData.position;
        float _x = flagRectTra.anchoredPosition.x;
        float _y = flagRectTra.anchoredPosition.y;
        DisposePoint(ref _x, ref _y);

        EventCenter.Broadcast<Vector3>(EventType.MoveTarget, new Vector3(_x, 0.5f, _y));
    }

    private void DisposePoint(ref float tmpX, ref float tmpY)
    {
        tmpX = (tmpX / mapSize.x * bounds.size.x) + bounds.min.x;
        tmpY = (tmpY / mapSize.y * bounds.size.z) + bounds.min.z;
    }

    private void FlagState(bool tmp)
    {
        flag.SetActive(tmp);
    }

    private void OnDestroy()
    {
        EventCenter.RemoveListener(EventType.UpdateMap, UpdateMapPoint);
        EventCenter.RemoveListener<bool>(EventType.FlagState, FlagState);
    }
}