C# 为什么我的攻击功能会摧毁包括攻击者在内的所有对象？

我们正在做一些2d项目。我们有一个棋盘，看起来像国际象棋棋盘（8x8），一些物体在这个棋盘的上方产生，就像俄罗斯方块一样。 当物体到达棋盘底部或其他物体时，它将向所有棋盘的4个方向攻击——上、下、左、右

我有3个脚本，Spawn，Obj_控制器和Personal_攻击。产卵脚本附加到产卵区空对象，两个不同的脚本都附加到我们产卵的对象。对象有标记-敌人，我使用它来检测我需要攻击的对象之间的差异，例如，产卵区和奖金（尚未准备好）。希望我提供足够的项目信息，让我们看看代码

繁殖我在游戏开始和每次攻击结束后用于繁殖对象

public class Spawn : MonoBehaviour
{
    public GameObject[] objects;
    Vector3 spotSpawn;
    // Start is called before the first frame update
    void Start()
    {
        spotSpawn = transform.position;
        //Debug.Log(spotSpawn);
        NewSpawn();
    }

    // Update is called once per frame
    void Update()
    {

    }

    public void NewSpawn()
    {

        int random_key = Random.Range(0,objects.Length - 1);
        Instantiate(objects[random_key], spotSpawn, Quaternion.identity);
    }
}

我使用Obj_控制器使物体移动，并在时机成熟时调用攻击

public class Obj_Controller : MonoBehaviour
{
    public float speed; // speed (I still dont use this var)

    [HideInInspector] public bool isMoved = true;   // movement flag
    [HideInInspector] public bool canSpawn = false; // spawn flag
    [HideInInspector] public bool attack = false; // attack flag

    bool LetFall = true; // falling flag

    [HideInInspector] public Animator anim; 


    // Start is called before the first frame update
    void Start()
    {

    }

    private void OnEnable()
    {
        anim = GetComponent<Animator>();
        //Debug.Log(transform.position);
    }



    // Update is called once per frame
    void Update()
    {
        if (isMoved == true && canSpawn == false)
        {
            Collider2D[] hitDown = Physics2D.OverlapCircleAll(transform.position - new Vector3(0, 1, 0), 0.5f);
            Collider2D[] hitLeft = Physics2D.OverlapCircleAll(transform.position - new Vector3(1, 0, 0), 0.5f);
            Collider2D[] hitRight = Physics2D.OverlapCircleAll(transform.position + new Vector3(1, 0, 0), 0.5f);


            if (hitDown.Length == 0)
            {
                //Check object can movew down in 1 cell
                if (LetFall == true)
                {
                    LetFall = false;
                    StartCoroutine(Down());
                }

                //Check object can move in  left or right side
                if (Input.GetKeyDown(KeyCode.LeftArrow) && hitLeft.Length == 0)
                {
                    transform.position -= new Vector3(1,0,0);
                }
                else if (Input.GetKeyDown(KeyCode.RightArrow) && hitRight.Length == 0)
                {
                    transform.position += new Vector3(1, 0, 0);
                }

            }
            else 
            {
                //Debug.Log(hitDown[0].name);
                isMoved = false;
                if(attack == false)
                {
                    attack = true;
                    gameObject.SendMessage("Attack");
                }

            }
        }
        else if(canSpawn == true)
        {
            canSpawn = false;
            GameObject spawner = GameObject.Find("SpawnZone");
            Spawn spawn = spawner.GetComponent<Spawn>();
            spawn.NewSpawn();
        }
        else
        {
            //Here will some functions, but later
        }
    }

    IEnumerator Down()
    {
        transform.position -= new Vector3(0,1, 0);
        yield return new WaitForSeconds(0.5f);
        LetFall = true;
    }

}

公共类Obj_控制器：单行为
{
公共浮点速度；//速度（我仍然不使用这个变量）
[HideInInstit]公共bool isMoved=true；//移动标志
[HideInInstitt]公共bool canSpawn=false；//spawn标志
[HideInInstitt]公共布尔攻击=false；//攻击标志
bool-LetFall=true；//降旗
[hideininstecpt]公共动画师动画；
//在第一帧更新之前调用Start
void Start（）
{
}
私有void OnEnable（）
{
anim=GetComponent（）；
//Debug.Log（transform.position）；
}
//每帧调用一次更新
无效更新（）
{
if（isMoved==true&&canSpawn==false）
{
Collized2D[]Hitton=Physics2D.OverlappCircleall（transform.position-新向量3（0,1,0），0.5f）；
Collider2D[]Hitlef=Physics2D.OverlappCircleall（transform.position-新向量3（1,0,0,0,0.5f）；
Collider2D[]hitRight=Physics2D.OverlappCircleall（transform.position+新向量3（1,0,0），0.5f）；
if（hitton.Length==0）
{
//检查对象是否可以在1个单元格中向下移动
如果（LetFall==true）
{
LetFall=假；
start例程（Down（））；
}
//检查对象是否可以向左或向右移动
if（Input.GetKeyDown（KeyCode.LeftArrow）&&hitLeft.Length==0）
{
transform.position-=新向量3（1,0,0）；
}
else if（Input.GetKeyDown（KeyCode.RightArrow）和&hitRight.Length==0）
{
transform.position+=新向量3（1,0,0）；
}
}
其他的
{
//Debug.Log（挂起[0].name）；
isMoved=假；
如果（攻击==错误）
{
攻击=真；
gameObject.SendMessage（“攻击”）；
}
}
}
else if（canSpawn==true）
{
canSpawn=false；
GameObject产卵器=GameObject.Find（“产卵区”）；
Spawn Spawn=spawner.GetComponent（）；
spawn.NewSpawn（）；
}
其他的
{
//这里将介绍一些函数，但稍后将介绍
}
}
IEnumerator Down（）
{
transform.position-=新向量3（0,1,0）；
收益率返回新的WaitForSeconds（0.5f）；
LetFall=true；
}
}

个人_攻击是试图在4个方向上找到其他对象的脚本，每次攻击的长度等于电路板的8个单元（每个步骤==1，每个对象的transform.position==单元中心）

公共类人身攻击：单行为
{
Obj_控制器Obj控制器；
//在第一帧更新之前调用Start
void OnEnable（）
{
objcontroller=GetComponent（）；
}
//每帧调用一次更新
无效更新（）
{
}
无效攻击（）
{
//攻击
对于（int i=1；i<9；i++）
{
Collider2D[]hitTop=Physics2D.OverlappCircleall（transform.position+新向量3（0，i，0），0.5f）；
foreach（hitTop中与R2D敌人相撞）
{
如果（敌方标签==“敌方”）
{
Debug.Log（敌方.变换.位置）；
摧毁（敌人。游戏对象）；
}
}
}
//击倒
对于（int i=1；i<9；i++）
{
Collider2D[]Hitton=Physics2D.OverlappCircleall（transform.position-新向量3（0，i，0），0.5f）；
foreach（击落时与R2D敌人相撞）
{
如果（敌方标签==“敌方”）
{
摧毁（敌人。游戏对象）；
}
}
}
//左击
对于（int i=1；i<9；i++）
{
Collider2D[]Hitlef=Physics2D.OverlappCircleall（transform.position-新向量3（i，0，0），0.5f）；
foreach（左击中与R2D敌人相撞）
{
如果（敌方标签==“敌方”）
{
摧毁（敌人。游戏对象）；
}
}
}
//右翼进攻
对于（int i=1；i<9；i++）
{
Collider2D[]hitRight=Physics2D.OverlappCircleall（transform.position+新向量3（i，0，0），0.5f）；
foreach（右翼与R2D敌人相撞）
{
如果（敌方标签==“敌方”）
{
摧毁（敌人。游戏对象）；
}
}
}
objcontroller.canSpawn=true；
}
}

---

因此，出于某种原因，攻击对象在攻击后不仅摧毁了它可以通过攻击到达的对象，而且也摧毁了它自己，游戏停止（没有生成，因为攻击者对象无法调用生成函数，因为它已经被摧毁了。）。我不明白我犯了什么错误。

我唯一能看到它何时会发生的方法是如果你的攻击者

public class Personal_Attack : MonoBehaviour
{

    Obj_Controller objcontroller;
    // Start is called before the first frame update
    void OnEnable()
    {
        objcontroller = GetComponent<Obj_Controller>();
    }

    // Update is called once per frame
    void Update()
    {

    }


    void Attack()
    {

        //Attack up
        for (int i = 1; i < 9; i++)
        {
            Collider2D[] hitTop = Physics2D.OverlapCircleAll(transform.position + new Vector3(0, i, 0), 0.5f);
            foreach (Collider2D enemy in hitTop)
            {
                if (enemy.tag == "Enemy")
                {
                    Debug.Log(enemy.transform.position);
                    Destroy(enemy.gameObject);
                }
            }
        }
        //Attack down
        for (int i = 1; i < 9; i++)
        {
            Collider2D[] hitDown = Physics2D.OverlapCircleAll(transform.position - new Vector3(0, i, 0), 0.5f);
            foreach (Collider2D enemy in hitDown)
            {
                if (enemy.tag == "Enemy")
                {
                    Destroy(enemy.gameObject);
                }
            }
        }
        //Attack left
        for (int i = 1; i < 9; i++)
        {
            Collider2D[] hitLeft = Physics2D.OverlapCircleAll(transform.position - new Vector3(i, 0, 0), 0.5f);
            foreach (Collider2D enemy in hitLeft)
            {
                if (enemy.tag == "Enemy")
                {
                    Destroy(enemy.gameObject);
                }
            }
        }
        //Attack right
        for (int i = 1; i < 9; i++)
        {
            Collider2D[] hitRight = Physics2D.OverlapCircleAll(transform.position + new Vector3(i, 0, 0), 0.5f);
            foreach (Collider2D enemy in hitRight)
            {
                if (enemy.tag == "Enemy")
                {
                    Destroy(enemy.gameObject);
                }
            }
        }

        objcontroller.canSpawn = true;

    }
}

if (enemy.tag == "Enemy" && enemy.gameObject != gameObject)
{
    Destroy(enemy.gameObject);
}

Collider2D[] hitTop = Physics2D.OverlapCircleAll(
        transform.position + new Vector3(0, i, 0), 
        0.5f - Mathf.Epsilon);