示例#1
0
    public override void SetActive()
    {
        if (IsActive())
        {
            return;
        }



        MapElement detectElement = GetFootBottomMiddleMapElement(transform.position);
        bool       isEmpty       = true;

        if (detectElement != null)
        {
            if (detectElement.IsBlock(MapElement.Dir_Up) != MapElement.Block_None)
            {
                isEmpty = false;
            }
        }

        if (_dir == MapElement.Dir_Left)
        {
            _speed.x = -1 * LineSpeed;
        }
        else
        {
            _speed.x = LineSpeed;
        }

        if (isEmpty)
        {
            _speed.y = -0.5f;
            SetStatus(Status_FallDown);
        }
        else
        {
            SetStatus(Status_Run);
        }
    }
示例#2
0
    public override void DoFixedUpdate()
    {
        if (_status != Status_Dead)
        {
            if (_gameMap.IsDeadMapPoint(_gameMap.GetMapPointOfWorldPosition(transform.position)) == true)
            {
                FalldownToDie();
                return;
            }
        }

        switch (_status)
        {
        case Status_Inactive:
            break;

        case Status_BounceUp:
        {
            Vector3 pos = transform.position;
            pos += _speed * Time.fixedDeltaTime;
            transform.position = pos;

            _timer -= Time.fixedDeltaTime;
            if (_timer < 0)
            {
                _speed.y = -0.5f;
                SetStatus(Status_FallDown);
            }
            break;
        }

        case Status_Run: {
            Vector3 pos = transform.position;
            pos += _speed * Time.fixedDeltaTime;

            int detectDir = MapElement.Dir_Right;
            if (_speed.x > 0)
            {
                detectDir = MapElement.Dir_Left;
            }

            MapElement detectElement = GetFrontMapElement(pos);
            if (detectElement != null)
            {
                if (detectElement.IsBlock(detectDir) != MapElement.Block_None)
                {
                    if (_speed.x < 0)
                    {
                        pos.x = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y).x + 1.0f;
                    }
                    else
                    {
                        pos.x = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y).x - 1.0f;
                    }
                    _speed.x *= -1;
                }
                else
                {
                    if (_speed.x < 0)
                    {
                        if (detectElement.type == MapElement.Type_WallSlope03Follow)
                        {
                            pos.x = Mathf.Round(pos.x) - 0.3f;
                            pos.y = Mathf.Round(pos.y) - 0.1f;
                            SetRunSlopeDown01(false);
                        }
                        else if (detectElement.type == MapElement.Type_WallSlope04)
                        {
                            pos.x = Mathf.Round(pos.x) - 0.2f;
                            pos.y = Mathf.Round(pos.y) - 0.2f;
                            SetRunSlopeDown02(false);
                        }
                    }
                    else if (_speed.x > 0)
                    {
                        if (detectElement.type == MapElement.Type_WallSlope01)
                        {
                            pos.x = Mathf.Round(pos.x) + 0.3f;
                            pos.y = Mathf.Round(pos.y) - 0.1f;
                            SetRunSlopeUp01(true);
                        }
                        else if (detectElement.type == MapElement.Type_WallSlope02)
                        {
                            pos.x = Mathf.Round(pos.x) + 0.2f;
                            pos.y = Mathf.Round(pos.y) - 0.2f;
                            SetRunSlopeUp02(true);
                        }
                    }
                }
            }
            else
            {
                detectElement = GetFootBottomMiddleMapElement(pos);
                bool isEmptyBelow = false;
                if (detectElement == null)
                {
                    isEmptyBelow = true;
                }
                else
                {
                    if (detectElement.type == MapElement.Type_WallSlope01Follow)
                    {
                        pos    = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y);
                        pos.x += 0.4f;
                        pos.y += 1.0f;
                        SetRunSlopeUp01(false);
                    }
                    else if (detectElement.type == MapElement.Type_WallSlope02)
                    {
                        pos    = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y);
                        pos.x += 0.4f;
                        pos.y += 1.0f;
                        SetRunSlopeUp02(false);
                    }
                    else if (detectElement.type == MapElement.Type_WallSlope03)
                    {
                        pos    = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y);
                        pos.x -= 0.4f;
                        pos.y += 1.0f;
                        SetRunSlopeDown01(true);
                    }
                    else if (detectElement.type == MapElement.Type_WallSlope04)
                    {
                        pos    = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y);
                        pos.x -= 0.4f;
                        pos.y += 1.0f;
                        SetRunSlopeDown02(true);
                    }
                    else if (detectElement.IsBlock(MapElement.Dir_Up) == MapElement.Block_None)
                    {
                        isEmptyBelow = true;
                    }
                }

                if (isEmptyBelow == true)
                {
                    _speed.y = -0.5f;
                    SetStatus(Status_FallDown);
                }
            }

            transform.position = pos;
            break;
        }

        case Status_RunSlope01:
        case Status_RunSlope02:
        case Status_RunSlope03:
        case Status_RunSlope04: {
            Vector3 pos = transform.position;
            pos += _speed * Time.fixedDeltaTime;
            float angle = (45 - transform.localEulerAngles.z) * 3.1415927f / 180;

            Vector3 detectPos = pos;

            if (_speed.x < 0)
            {
                detectPos.x -= ((_width / 2 + _detectDelta) * 1.414f * Mathf.Sin(angle));
                detectPos.y -= (_height / 2 - _detectDelta) * 1.414f * Mathf.Cos(angle);
            }
            else
            {
                detectPos.x += ((_width / 2 + _detectDelta) * 1.414f * Mathf.Cos(angle));
                detectPos.y -= (_height / 2 - _detectDelta) * 1.414f * Mathf.Sin(angle);
            }

            MapPoint   detectMapPoint = _gameMap.GetMapPointOfWorldPosition(detectPos);
            MapElement detectElement  = _gameMap.GetMapElementByMapPoint(detectMapPoint.x, detectMapPoint.y);

            if (detectElement != null)
            {
                if ((((_status == Status_RunSlope01) || (_status == Status_RunSlope02)) && (_speed.x < 0)) || (((_status == Status_RunSlope03) || (_status == Status_RunSlope04)) && (_speed.x > 0)))
                {
                    if ((detectElement.type != MapElement.Type_WallSlope01) && (detectElement.type != MapElement.Type_WallSlope01Follow) && (detectElement.type != MapElement.Type_WallSlope02) &&
                        (detectElement.type != MapElement.Type_WallSlope03) && (detectElement.type != MapElement.Type_WallSlope03Follow) && (detectElement.type != MapElement.Type_WallSlope04) &&
                        (detectElement.type != MapElement.Type_WallSlopeBottom))
                    {
                        pos = SetSlopeToRunDown(detectMapPoint);
                    }
                }
            }
            detectPos = pos;

            if (_speed.x < 0)
            {
                detectPos.x -= ((_width / 2 + _detectDelta) * 1.414f * Mathf.Sin(angle));
                detectPos.y -= ((_height / 2 + _detectDelta) * 1.414f * Mathf.Cos(angle) + _detectDelta);
            }
            else
            {
                detectPos.x += ((_width / 2 + _detectDelta) * 1.414f * Mathf.Cos(angle));
                detectPos.y -= ((_height / 2 + _detectDelta) * 1.414f * Mathf.Sin(angle) + _detectDelta);
            }

            detectMapPoint = _gameMap.GetMapPointOfWorldPosition(detectPos);
            detectElement  = _gameMap.GetMapElementByMapPoint(detectMapPoint.x, detectMapPoint.y);

            if (detectElement == null)
            {
                pos = SetSlopeToRunUp(detectMapPoint);
            }

            transform.position = pos;
            break;
        }

        case Status_FallDown:
        {
            Vector3 pos = transform.position;
            pos += _speed * Time.fixedDeltaTime;

            _speed.y += Gravity * Time.fixedDeltaTime;

            MapElement detectElement = GetFrontTopMapElement(pos);

            bool isBlocked = false;
            int  detectDir = MapElement.Dir_Right;
            if (_speed.x > 0)
            {
                detectDir = MapElement.Dir_Left;
            }

            if (detectElement != null)
            {
                if (detectElement.IsBlock(detectDir) != MapElement.Block_None)
                {
                    if (_speed.x < 0)
                    {
                        pos.x = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y).x + 1.0f;
                    }
                    else
                    {
                        pos.x = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y).x - 1.0f;
                    }
                    _speed.x *= -1;
                    isBlocked = true;
                }
            }

            if (isBlocked == false)
            {
                detectElement = GetFrontMapElement(pos);
                if (detectElement != null)
                {
                    if (detectElement.IsBlock(detectDir) != MapElement.Block_None)
                    {
                        if (_speed.x < 0)
                        {
                            pos.x = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y).x + 1.0f;
                        }
                        else
                        {
                            pos.x = _gameMap.GetWorldPositionByMapPoint(detectElement.x, detectElement.y).x - 1.0f;
                        }
                        _speed.x *= -1;
                        isBlocked = true;
                    }
                }
            }

            bool    isMoveForward = _speed.x > 0;
            Vector3 detectPos     = pos;
            detectPos.y -= (_height / 2 + _detectDelta);

            MapPoint detectMapPoint = _gameMap.GetMapPointOfWorldPosition(detectPos);

            detectElement = _gameMap.GetMapElementByMapPoint(detectMapPoint.x, detectMapPoint.y);
            if (detectElement != null)
            {
                // 下面有障碍,判断是不是落在斜坡上
                if ((detectElement.type == MapElement.Type_WallSlope01) || (detectElement.type == MapElement.Type_WallSlope01Follow))
                {
                    Vector3 deltaPos = pos;
                    deltaPos.x += 0.2f;
                    deltaPos.x  = deltaPos.x - (int)deltaPos.x;
                    if (detectElement.type == MapElement.Type_WallSlope01)
                    {
                        deltaPos.y = deltaPos.x / 2;
                    }
                    else
                    {
                        Debug.Log("Add 0.5.");
                        deltaPos.y = deltaPos.x / 2 + 0.5f;
                    }
                    deltaPos.x += detectElement.transform.position.x - 0.5f;
                    deltaPos.y += detectElement.transform.position.y - 0.5f;

                    float angle = (45 - Slope01Angle) * 3.1415927f / 180;
                    if (isMoveForward)
                    {
                        pos.x = deltaPos.x - 0.707f * Mathf.Cos(angle);
                        pos.y = deltaPos.y + 0.707f * Mathf.Sin(angle);
                        SetRunSlopeUp01(isMoveForward);
                    }
                    else
                    {
                        // 向后走,前角在低处
                        pos.x = deltaPos.x + 0.707f * Mathf.Sin(angle);
                        pos.y = deltaPos.y + 0.707f * Mathf.Cos(angle);
                        SetRunSlopeUp01(isMoveForward);
                    }
                }
                else if (detectElement.type == MapElement.Type_WallSlope02)
                {
                    Vector3 deltaPos = pos;
                    deltaPos.x += 0.2f;
                    deltaPos.x  = deltaPos.x - (int)deltaPos.x;
                    deltaPos.y  = deltaPos.x;

                    deltaPos.x += detectElement.transform.position.x - 0.5f;
                    deltaPos.y += detectElement.transform.position.y - 0.5f;


                    float angle = (45 - Slope02Angle) * 3.1415927f / 180;
                    if (isMoveForward)
                    {
                        pos.x = deltaPos.x - 0.707f * Mathf.Cos(angle);
                        pos.y = deltaPos.y + 0.707f * Mathf.Sin(angle);
                        SetRunSlopeUp02(isMoveForward);
                    }
                    else
                    {
                        // 向后走,前角在低处
                        pos.x = deltaPos.x + 0.707f * Mathf.Sin(angle);
                        pos.y = deltaPos.y + 0.707f * Mathf.Cos(angle);
                        SetRunSlopeUp02(isMoveForward);
                    }
                }
                else if ((detectElement.type == MapElement.Type_WallSlope03) || (detectElement.type == MapElement.Type_WallSlope03Follow))
                {
                    // 碰到了斜坡
                    Vector3 deltaPos = pos;
                    deltaPos.x += 0.5f;
                    deltaPos.x  = deltaPos.x - (int)deltaPos.x;
                    if (detectElement.type == MapElement.Type_WallSlope03)
                    {
                        deltaPos.y = deltaPos.x / 2;
                    }
                    else
                    {
                        deltaPos.y = deltaPos.x / 2 + 0.5f;
                    }
                    deltaPos.x += detectElement.transform.position.x - 0.5f;
                    deltaPos.y  = detectElement.transform.position.y + 0.5f - deltaPos.y;

                    float angle = (Slope01Angle - 315) * 3.1415927f / 180;
                    if (isMoveForward)
                    {
                        pos.x = deltaPos.x - 0.707f * Mathf.Cos(angle);
                        pos.y = deltaPos.y + 0.707f * Mathf.Sin(angle);
                        SetRunSlopeDown01(isMoveForward);
                    }
                    else
                    {
                        // 向后走,前角在低处
                        pos.x = deltaPos.x + 0.707f * Mathf.Sin(angle);
                        pos.y = deltaPos.y + 0.707f * Mathf.Cos(angle);
                        SetRunSlopeDown01(isMoveForward);
                    }
                }
                else if (detectElement.type == MapElement.Type_WallSlope04)
                {
                    // 碰到了斜坡
                    Vector3 deltaPos = pos;
                    deltaPos.x += 0.4f;
                    deltaPos.x  = deltaPos.x - (int)deltaPos.x;
                    deltaPos.y  = deltaPos.x;

                    deltaPos.x += detectElement.transform.position.x - 0.5f;
                    deltaPos.y  = detectElement.transform.position.y + 0.5f - deltaPos.y;


                    float angle = (Slope02Angle - 315) * 3.1415927f / 180;
                    if (isMoveForward)
                    {
                        pos.x = deltaPos.x - 0.707f * Mathf.Cos(angle);
                        pos.y = deltaPos.y + 0.707f * Mathf.Sin(angle);
                        SetRunSlopeDown02(isMoveForward);
                    }
                    else
                    {
                        // 向后走,前角在低处
                        pos.x = deltaPos.x + 0.707f * Mathf.Sin(angle);
                        pos.y = deltaPos.y + 0.707f * Mathf.Cos(angle);
                        SetRunSlopeDown02(isMoveForward);
                    }
                }
                else if (detectElement.IsBlock(MapElement.Dir_Up) != MapElement.Block_None)
                {
                    _speed.y = 0;
                    pos.y    = detectElement.transform.position.y + 0.5f + _height / 2;
                    SetStatus(Status_Run);

                    if (this is Mushroom)
                    {
                        _speed.x = ActorController.instance.ActorSpeedX;
                    }
                }
            }

            transform.position = pos;
            break;
        }

        case Status_FlyToActor:
        {
            DoFixedUpdateFlyToActor();
            break;
        }
        }
    }