//基础声明语法
[Exprot]
public int age{set;get;}

//限制最大最小
[Export(PropertyHint.Range,"0,100,1")] 

//整值枚举
[Export(PropertyHint.Enum,"A,B")]        //输出1,2
//字符串枚举
[Export(PropertyHint.EnumSuggestion ,"A,B")]    //输出A,B

//曲线
[Export(PropertyHint.ExpEasing,"positive_only")] 

//锁 Link
[Export(PropertyHint.Link)] 

//标志flags
[Export(PropertyHint.Flags,"A:16,B,C")]  


//注册类到godot
[GlobalClass]
//自定义图标
[Icon("icon.svg")]

[Signal]
public delegate void 我的信号EventHandler(); //声明信号

EmitSignal(nameof(我的信号));               //发送信号

我的信号+=函数                               //链接信号

public delegate 委托函数(int age);  //声明委托

public event 委托函数 信号;  //声明事件

信号.Invoke();  //发送信号

信号+=函数;     //链接信号

public void 函数(int age);

public async Task SomeFunction()
 {
     //func();
     GD.Print("开始计时");
     await ToSignal(GetTree().CreateTimer(5.0f,true),             SceneTreeTimer.SignalName.Timeout);
     GD.Print("计时结束");
     //无敌=false;
 }

System.Threading.Thread.Sleep(5000); // 休眠1秒  

static async Task<string> FetchDataFromWebAsync()
{
    Console.WriteLine($"FetchDataFromWebAsync: 启动web请求...");

    // 使用HttpClient发送HTTP GET请求（这是异步的）  
    var response = await client.GetAsync("https://example.com"); // 假设这个URL返回一个字符串  
    var content = await response.Content.ReadAsStringAsync(); // 读取响应内容  
    //await Task.Delay(5000);
    Console.WriteLine($"FetchDataFromWebAsync: Web请求完成.");

    // 返回结果（这里简单地返回响应内容，实际中可能是解析后的数据）  
    return content;
}

System.Timers.Timer countdownTimer;  
int countdownSeconds = 1; // 假设倒计时10秒 

    countdownTimer=new System.Timers.Timer(1000);
    countdownTimer.Elapsed+=函数;
    countdownTimer.AutoReset = true; // 设置为true以便定时器持续触发  
    countdownTimer.Enabled = true;  // 启动定时器  

public static Variant 读取数据(string paths)
{
FileAccess dile= FileAccess.Open(paths,FileAccess.ModeFlags.Read);              //通过路径打开文件,打开文件返回空
        if(FileAccess.GetOpenError()==Error.Ok)                                     //检查是否打开文件
        {
            GD.Print("打开成功");
        }else
        {
            GD.Print("打开失败");
            return false;
        }
    string 解析=dile.GetAsText();                                                   //以String返回整个文件,文件会按照UTF-8编码解析
    Variant? 转换=Json.ParseString(解析);                                             //将解析到的字符串转换为GODOT可以识别的Variant数据
    if(转换==null)
    {
        GD.Print("解析数据失败");
        return false;
    }
    dile.Close();
    return (Variant)转换;         //将Variant数据返回
}

public void duqu()
{
    using (var workbook = new XLWorkbook("./Json/xxxc.xlsx"))
    {
        var worksheet = workbook.Worksheet(1); // 假设要读取第一个工作表

        var dataTable = new System.Data.DataTable();
        //bool firstRow = true; // 用来标记是否是第一行
        // 从工作表数据填充到DataTable
        foreach (var row in worksheet.RowsUsed())
        {
        //if (firstRow) // 如果是第一行，跳过并将标记设为false
         //{
         //    firstRow = false;
         //    continue;
         //}

            if (row.RowNumber() == 1) // 处理表头
            {
                foreach (var cell in row.CellsUsed())
                {
                    dataTable.Columns.Add(cell.Value.ToString());
                }
            }
            else // 处理数据行
            {
                var dataRow = dataTable.NewRow();
                foreach (var cell in row.CellsUsed())
                {
                    dataRow[cell.Address.ColumnNumber - 1] = cell.Value.ToString();
                }
                dataTable.Rows.Add(dataRow);
            }
        }

        // 将DataTable转换为JSON
        string json = JsonConvert.SerializeObject(dataTable, Formatting.Indented);
        // string json = JsonSerializer.Serialize(dataTable, new JsonSerializerOptions { WriteIndented = true });
        File.WriteAllText("./Json/output.json", json);

        // 打印JSON数据
        //Console.WriteLine(json);
        GD.Print(json);
    }
}

//玩家范围内生成 GD.Randf()返回随机浮点
float x = PlayerP1.Position.X + GD.Randf() * 600 - 10;
float y = PlayerP1.Position.Y + GD.Randf() * 600 - 10;
Vector2 pos = new Vector2(x, y); //这个位置就是随机位置的值,给敌人位置即可

//返回随机位置
public Vector3 Get_Vector(Vector3 center, float range)
    {
        Vector3 random_offset =new Vector3(
            GetRandomFloat(-range, range),
            GetRandomFloat(-range, range),
            GetRandomFloat(-range, range)
        );

        return center + random_offset;
    }
//返回随机浮点
static float GetRandomFloat(float min, float max)
    {
        Random random = new Random();
        return (float)(random.NextDouble() * (max - min) + min);
    }

public Vector3 Get_Vleor(NodeA,NodeB)
{
    Vector3 dir=(NodeA-NodeB).初始化向量();
    return dir;
}

using Godot;
using System;

public partial class EnemyFactory : Node3D
{
    /// <summary>
    /// 怪物体
    /// </summary>
    [Export]
    public CharacterBody3D EnemyBody { get; set; }
    /// <summary>
    /// 生成位置
    /// </summary>
    [Export]
    public Vector3 GenerateLocation { get; set;}
    /// <summary>
    /// 生成范围
    /// </summary>
    [Export]
    public float GenerateScope { get; set; }
    /// <summary>
    /// 怪物根节点
    /// </summary>
    Node3D EnemyRoot { get; set; }
    /// <summary>
    /// 怪物最大数量
    /// </summary>
    [Export]
    public int MaxEnemyCount { get; set; }
    /// <summary>
    /// 计时器
    /// </summary>
    public Timer timer { get; set; }=new Timer();
    /// <summary>
    /// 间隔时间
    /// </summary>
    [Export]
    public float time {  get; set; }=1;

    // Called when the node enters the scene tree for the first time.
    public override void _EnterTree()
    {



        //GlobalPosition = Get_Vector(GenerateLocation,GenerateScope);
    }
    public override void _Ready()
    {
        //生成计时器并开启
        timer.WaitTime = time;
        timer.Autostart = true;
        timer.Timeout += On_Timer_timeout;
        AddChild(timer);
        //添加怪物节点的根,怪物将生成在这个节点下
        EnemyRoot = new Node3D();
        EnemyRoot.Name="EnemyRoot";
        AddChild(EnemyRoot);
    }

    // Called every frame. 'delta' is the elapsed time since the previous frame.
    public override void _Process(double delta)
    {
    }

    private void On_Timer_timeout()
    {
        if (EnemyRoot.GetChildren().Count >= 50)
        {
            return;
        }
        if (EnemyBody != null)
        {
            CharacterBody3D EnemyBody1 = (CharacterBody3D)EnemyBody.Duplicate();
            EnemyBody1.Position = Get_Vector(GenerateLocation, GenerateScope);
            EnemyRoot.AddChild(EnemyBody1);

        }
    }
    /// <summary>
    /// 返回随机位置
    /// </summary>
    /// <param name="center"></param>
    /// <param name="range"></param>
    /// <returns></returns>
    public Vector3 Get_Vector(Vector3 center, float range)
    {
        Vector3 random_offset =new Vector3(
            GetRandomFloat(-range, range),
            GetRandomFloat(-range, range),
            GetRandomFloat(-range, range)
        );

        return center + random_offset;
    }
    /// <summary>
    /// 返回一个随机浮点数
    /// </summary>
    /// <param name="min"></param>
    /// <param name="max"></param>
    /// <returns></returns>
    static float GetRandomFloat(float min, float max)
    {
        Random random = new Random();
        return (float)(random.NextDouble() * (max - min) + min);
    }
}

using Godot;
[Tool]

public partial class Enemy : CharacterBody3D
{
    [Export]
    public PackedScene EnemyTscn {  get; set; }

    [Export]
    public Mesh mesh { get; set; }
    [Export]
    public CollisionShape3D shape3D { get; set; }
    [Export]
    public Shape3D shape { get; set; }

    [Export]
    public Node3D Player { get; set; }

    public const float Speed = 5.0f;
    public const float JumpVelocity = 4.5f;
    public override void _EnterTree()
    {
        shape3D = new CollisionShape3D();
        if (shape3D != null)
        {
            shape3D.Shape=shape;
            AddChild(shape3D);
        }
        //if(EnemyTscn != null)
        //{
        //    MeshInstance3D meshInstance = EnemyTscn.Instantiate() as MeshInstance3D;
        //    return;
        //}
        if(mesh != null)
        {
            MeshInstance3D EnemyMesh =new MeshInstance3D();
            EnemyMesh.Mesh = mesh;
            AddChild(EnemyMesh);
        }
    }

    public override void _PhysicsProcess(double delta)
    {
        Vector3 velocity = Velocity;

        // Add the gravity.
        if (!IsOnFloor())
        {
            velocity += GetGravity() * (float)delta;
        }

        if (Player != null) 
        {
            Vector3 dir = (Player.GlobalPosition - GlobalPosition).Normalized();
            velocity = dir * (float)delta;
        }

        Velocity = velocity;
        MoveAndSlide();
    }
}

using Godot;
using Godot.Collections;

public partial class SelfFiringWeapon : Node3D
{
    // Called when the node enters the scene tree for the first time.
    [Export]
    public CharacterBody3D Bullet { get; set; }
    [Export]
    public MeshInstance3D Weapon { get; set; }
    [Export]
    public Marker3D BulletLocation { get; set; }
    [Export]
    public Marker3D BulletDirection { get; set; }
    [Export]
    public EnemyFactory EnemyRoot { get; set; }

    [Export]
    public Timer Timer { get; set; }

    public override void _Ready()
    {
        Timer.Timeout += ON_TimerTimeout;  // 绑定超时事件
    }

    // Called every frame. 'delta' is the elapsed time since the previous frame.
    public override void _Process(double delta)
    {


        CharacterBody3D enemy = GetNearestEnemy(this);  // 获取最近的敌人
        if (enemy != null)  // 如果有敌人
        {
            LookAt(enemy.GlobalPosition);  // 面向敌人
            GD.Print("正在跟踪敌人");
        }
    }

    public void ON_TimerTimeout()
    {
        CharacterBody3D weapon = Bullet.Duplicate() as CharacterBody3D;  // 获取武器
        GetParent().AddChild(weapon);
        weapon.GlobalPosition = BulletLocation.GlobalPosition;  // 设置武器位置

        Vector3 Dir=(BulletDirection.GlobalPosition-BulletLocation.GlobalPosition).Normalized();  // 计算武器方向
        weapon.Velocity=Dir * 10f;  //  //Dir * 100f;  // 设置武器速度
          // 添加武器到场景
        GD.Print("发射子弹");
    }


    public CharacterBody3D GetNearestEnemy(Node3D player)
    {
        if (EnemyRoot != null && EnemyRoot.EnemyRoot == null)
        {
            return null;
        }
        // 获取所有子节点（怪物）
        Array<Node> enemiesArray = EnemyRoot.EnemyRoot.GetChildren();
        Enemy nearestEnemy = null;
        float nearestDistance = float.PositiveInfinity;  // 使用正无穷大作为初始值

        // 遍历所有怪物
        foreach (Enemy enemy in enemiesArray)
        {
            if (enemy is Enemy)  // 假设敌人是 CharacterBody3D 类型
            {
                // 计算与玩家的距离
                float distance = player.GlobalPosition.DistanceTo(enemy.GlobalPosition);
                if (distance < nearestDistance)  // 找到最近的怪物
                {
                    nearestDistance = distance;
                    nearestEnemy = (Enemy)enemy;  // 更新最近的怪物
                }
            }
        }
        return nearestEnemy;  // 返回最近的怪物
    }
}