/// <summary>
/// 比赛场地的长度
/// </summary>
public double FieldLength;

/// <summary>
/// 比赛场地的宽度
/// </summary>
public double FieldWidth;

/// <summary>
/// 禁区的长度
/// </summary>
public double FieldPNZLength;

/// <summary>
/// 禁区的宽度
/// </summary>
public double FieldPNZWidth;

/// <summary>
/// 中场圆的半径
/// </summary>
public double FieldMidCircleRadius;

/// <summary>
/// 球门的宽度
/// </summary>
public double FieldDoorWidth;

/// <summary>
/// 球门的Y坐标（较小的）
/// </summary>
public double FieldDoorY1;

/// <summary>
/// 球门的Y坐标（较大的）
/// </summary>
public double FieldDoorY2;

/// <summary>
/// 比赛场地的左顶点位置
/// </summary>
public Vector2f FieldLeftTopPos

/// <summary>
/// 比赛场地的右底点位置
/// </summary>
public Vector2f FieldRightBottomPos

/// <summary>
/// 比赛场地的矩形区域
/// </summary>
public Rectangle Field



/// <summary>
/// 比赛场地的左半场区域
/// </summary>
public Rectangle LeftField

/// <summary>
/// 比赛场地的右半场区域
/// </summary>
public Rectangle RightField

/// <summary>
/// 比赛场地的左禁区区域
/// </summary>
public Rectangle LeftPNZ

/// <summary>
/// 比赛场地的右禁区区域
/// </summary>
public Rectangle RightPNZ

/// <summary>
/// 执行Stay命令，这是一个空命令，什么也不做，Just stay；）
/// </summary>
/// <param name="wm">场上的信息</param>
/// <param name="command">命令参数</param>
/// <param name="num">执行该命令的球员编号</param>
/// <returns>命令是否执行成功</returns>
public bool Perform(WorldModel wm, Command command, int num)
{
    return true;
}

/// <summary>
/// 执行Turn命令。
/// 这个命令中只有Command.parameter1是有效的，代表该球员希望转身以后的角度。
/// </summary>
/// <param name="wm">场上的信息</param>
/// <param name="command">命令参数</param>
/// <param name="num">执行该命令的球员编号</param>
/// <returns>命令是否执行成功</returns>
public bool Perform(WorldModel wm, Command command, int num)
{
    //确保转身后的角度在有效的范围内
    double turnAng =AngleHelper.NormalizeAngle(command.Parameter1);

    wm.agents[num].Dir = turnAng;

    return true;
}

/// <summary>
/// 执行Dash命令。可以让指定的球员在一个周期内向前或向后移动一定的距离
/// 这个命令中只有Command.parameter1是有效的，代表该球员希望获得的速度。
/// </summary>
/// <param name="wm">场上的信息</param>
/// <param name="command">命令参数</param>
/// <param name="num">执行该命令的球员编号</param>
/// <returns>命令是否执行成功</returns>
public bool Perform(WorldModel wm, Command command, int num)
{
    double dashVel = command.Parameter1;

    //确保球员的速度不越界
    if (dashVel > RuleSettings.Instance.MaxDashVel)
    {
        dashVel = RuleSettings.Instance.MaxDashVel;
    }
    else if (dashVel < RuleSettings.Instance.MinDashVel)
    {
        dashVel = RuleSettings.Instance.MinDashVel;
    }

    Vector2f dashPos = new Vector2f(dashVel, wm.agents[num].Dir, true) + wm.agents[num].Pos;

    //球员出了球场，计算反弹后的位置
    if (!FieldSettings.Instance.Field.IsInside(dashPos))
    {
        Line l = Line.MakeLineFromPositionAndAngle(wm.agents[num].Pos, wm.agents[num].Dir);

        Line[] ls = new Line[4];
        ls[0] =
            Line.MakeLineFromTwoPoints(FieldSettings.Instance.FieldLeftTopPos,
                                       new Vector2f(FieldSettings.Instance.FieldLength, 0));
        ls[1] =
            Line.MakeLineFromTwoPoints(new Vector2f(0, FieldSettings.Instance.FieldWidth),
                                       FieldSettings.Instance.FieldRightBottomPos);
        ls[2] =
            Line.MakeLineFromTwoPoints(FieldSettings.Instance.FieldLeftTopPos,
                                       new Vector2f(0, FieldSettings.Instance.FieldWidth));
        ls[3] =
            Line.MakeLineFromTwoPoints(new Vector2f(FieldSettings.Instance.FieldLength, 0),
                                       FieldSettings.Instance.FieldRightBottomPos);

        double minDis = 9999;
        Vector2f newPos = new Vector2f(wm.agents[num].Pos);

        foreach (Line line in ls)
        {
            Vector2f collidePos = l.GetIntersection(line);

            if (collidePos.GetDistanceTo(wm.agents[num].Pos) < minDis)
            {
                newPos = collidePos;
                minDis = collidePos.GetDistanceTo(wm.agents[num].Pos);
            }
        }

        wm.agents[num].Pos = newPos;

        return false;
    }
    else
    {
        wm.agents[num].Pos = dashPos;

        return true;
    }
}

/// <summary>
/// 执行Dash命令。可以让指定的球员在本周期给足球添加一个速度
/// Command.parameter1 代表速度的大小
/// Command.parameter2 代表速度的方向
/// </summary>
/// <param name="wm">场上的信息</param>
/// <param name="command">命令参数</param>
/// <param name="num">执行该命令的球员编号</param>
/// <returns>命令是否执行成功</returns>
public bool Perform(WorldModel wm, Command command, int num)
{
    //如果球员于足球的距离大于MaxKickBallDistance，则踢球失败
    if (wm.agents[num].Pos.GetDistanceTo(wm.ball.Pos) > RuleSettings.Instance.MaxKickBallDistance)
    {
        return false;
    }

    double kickVelocity = command.Parameter1;

    //确保踢球的角度在有效的范围内
    double kickAngle = AngleHelper.NormalizeAngle(command.Parameter2);

    //确保踢球的速度在有效的范围内
    if (kickVelocity > RuleSettings.Instance.MaxKickBallVelocity)
    {
        kickVelocity = RuleSettings.Instance.MaxKickBallVelocity;
    }
    else if (kickVelocity < RuleSettings.Instance.MinKickBallVelocity)
    {
        kickVelocity = RuleSettings.Instance.MinKickBallVelocity;
    }

    wm.ball.Vel += new Vector2f(kickVelocity, kickAngle, true);

    return true;
}

/// <summary>
/// 扑球的命令类，可以让守门员在本周期把足球停止住，同时让对方的球员移出自己边的禁区
/// 球员在自己的禁区扑球一次以后，必须等球出了自己的禁区才能再次使用该命令
/// </summary>
/// <param name="wm">场上的信息</param>
/// <param name="command">命令参数</param>
/// <param name="num">执行该命令的球员编号</param>
/// <returns>命令是否执行成功</returns>
public bool Perform(WorldModel wm, Command command, int num)
{
    //只有守门员可以执行这个命令
    if ((num % RuleSettings.Instance.AgentNum + 1) != RuleSettings.Instance.CatchNum)
    {
        return false;
    }

    //判断是否连续扑球
    if ( (num < RuleSettings.Instance.AgentNum && !CanLeftTeamCatch) || !CanRightTeamCatch)
    {
        return false;
    }

    //判断扑球的距离是否合理
    if (wm.ball.Pos.GetDistanceTo(wm.agents[num].Pos) > RuleSettings.Instance.MaxCatchBallDistance)
    {
        return false;
    }

    Rectangle PNZ;
    int startIndex;
    bool left = false;
    
    if (num < RuleSettings.Instance.AgentNum)
    {
        startIndex = RuleSettings.Instance.AgentNum;
        PNZ = FieldSettings.Instance.LeftPNZ;
        left = true;
    }
    else
    {
        startIndex = 0;
        PNZ = FieldSettings.Instance.RightPNZ;
        left = false;
    }

    //球必须在禁区中
    if (!PNZ.IsInside(wm.ball.Pos))
    {
        return false;
    }

    //让球停止运动
    wm.ball.Stop();
    //将对方的球员移除自己的禁区
    for (int i = startIndex; i < startIndex + RuleSettings.Instance.AgentNum; i++)
    {
        if (PNZ.IsInside(wm.agents[i].Pos))
        {
            if (left)
            {
                wm.agents[i].Pos = new Vector2f(PNZ.PosRightBottom.X, wm.agents[i].Pos.Y);
            }
            else
            {
                wm.agents[i].Pos = new Vector2f(PNZ.PosLeftTop.X, wm.agents[i].Pos.Y);
            }
        }
    }

    //不能连续扑球的设置
    if (left)
    {
        CanLeftTeamCatch = false;
    }
    else
    {
        CanRightTeamCatch = false;
    }

    return true;

}

/// <summary>
/// 让足球在当前的速度下运动一个周期
/// </summary>
/// <returns>返回球的状态，通过球的状态，可以知道是否进球。</returns>
public void DoMove()
{
    //如果球的速度过大，则让球的速度大小变为BallMaxVelocity，方向不变
    if (_vel.GetLength() > RuleSettings.Instance.BallMaxVelocity)
    {
        _vel.SetLength(RuleSettings.Instance.BallMaxVelocity);
    }

    Vector2f newPos = _pos + _vel;

    //球到了左边球门中，右方进球
    if (newPos.X <= 0 &&
        newPos.IsBetweenY(FieldSettings.Instance.FieldDoorY1,
                          FieldSettings.Instance.FieldDoorY2))
    {
        _pos = newPos;
        _state = BallState.RightGoal;
        return;
    }
    //球到了右边球门中，左方进球
    else if (newPos.X >= FieldSettings.Instance.FieldLength &&
             newPos.IsBetweenY(FieldSettings.Instance.FieldDoorY1,
                               FieldSettings.Instance.FieldDoorY2))
    {
        this.Pos = newPos;
        _state = BallState.LeftGoal;
        return;
    }

    //球出了球场，计算反弹后的位置和速度(位置和速度取反)
    if (!FieldSettings.Instance.Field.IsInside(newPos))
    {
        if (newPos.X < 0)
        {
            newPos.X = -newPos.X;
            _vel.X = -_vel.X;
        }
        else if (newPos.X > FieldSettings.Instance.FieldLength)
        {
            newPos.X = FieldSettings.Instance.FieldLength -
                       (newPos.X - FieldSettings.Instance.FieldLength);
            _vel.X = -_vel.X;
        }

        if (newPos.Y < 0)
        {
            newPos.Y = -newPos.Y;
            _vel.Y = -_vel.Y;
        }
        else if (newPos.Y > FieldSettings.Instance.FieldWidth)
        {
            newPos.Y = FieldSettings.Instance.FieldWidth -
                       (newPos.Y - FieldSettings.Instance.FieldWidth);
            _vel.Y = -_vel.Y;
        }
    }

    //设置球的位置
    _pos = newPos;
    //球的速度衰减
    _vel *= RuleSettings.Instance.BallDelayRate;

    if (!FieldSettings.Instance.LeftPNZ.IsInside(_pos))
    {
        CatchCommand.CanLeftTeamCatch = true;
    }
    else if (!FieldSettings.Instance.RightField.IsInside(_pos))
    {
        CatchCommand.CanRightTeamCatch = true;
    }
}