UpdateFrame()

void Terraria.Mount.UpdateFrame ( Player mountedPlayer, int state, Vector2 velocity )

inline

Definition at line 3023 of file Mount.cs.

    {
        if (_frameState != state)
        {
            _frameState = state;
            if (_type != 48 || (state != 1 && state != 2))
            {
                _frameCounter = 0f;
            }
        }
        if (state != 0)
        {
            _idleTime = 0;
        }
        if (_data.emitsLight)
        {
            Point point = mountedPlayer.Center.ToTileCoordinates();
            Lighting.AddLight(point.X, point.Y, _data.lightColor.X, _data.lightColor.Y, _data.lightColor.Z);
        }
        switch (_type)
        {
        case 52:
            if (state == 4)
            {
                state = 2;
            }
            break;
        case 17:
            UpdateFrame_GolfCart(mountedPlayer, state, velocity);
            break;
        case 5:
            if (state != 2)
            {
                _frameExtra = 0;
                _frameExtraCounter = 0f;
            }
            break;
        case 7:
            state = 2;
            break;
        case 49:
        {
            if (state != 4 && mountedPlayer.wet)
            {
                _frameState = (state = 4);
            }
            velocity.Length();
            float num5 = mountedPlayer.velocity.Y * 0.05f;
            if (mountedPlayer.direction < 0)
            {
                num5 *= -1f;
            }
            mountedPlayer.fullRotation = num5;
            mountedPlayer.fullRotationOrigin = new Vector2(mountedPlayer.width / 2, mountedPlayer.height / 2);
            break;
        }
        case 43:
            if (mountedPlayer.velocity.Y == 0f)
            {
                mountedPlayer.isPerformingPogostickTricks = false;
            }
            if (mountedPlayer.isPerformingPogostickTricks)
            {
                mountedPlayer.fullRotation += (float)mountedPlayer.direction * ((float)Math.PI * 2f) / 30f;
            }
            else
            {
                mountedPlayer.fullRotation = (float)Math.Sign(mountedPlayer.velocity.X) * Utils.GetLerpValue(0f, RunSpeed - 0.2f, Math.Abs(mountedPlayer.velocity.X), clamped: true) * 0.4f;
            }
            mountedPlayer.fullRotationOrigin = new Vector2(mountedPlayer.width / 2, (float)mountedPlayer.height * 0.8f);
            break;
        case 9:
            if (_aiming)
            {
                break;
            }
            _frameExtraCounter += 1f;
            if (_frameExtraCounter >= 12f)
            {
                _frameExtraCounter = 0f;
                _frameExtra++;
                if (_frameExtra >= 6)
                {
                    _frameExtra = 0;
                }
            }
            break;
        case 46:
            if (state != 0)
            {
                state = 1;
            }
            if (!_aiming)
            {
                if (state == 0)
                {
                    _frameExtra = 12;
                    _frameExtraCounter = 0f;
                    break;
                }
                if (_frameExtra < 12)
                {
                    _frameExtra = 12;
                }
                _frameExtraCounter += Math.Abs(velocity.X);
                if (_frameExtraCounter >= 8f)
                {
                    _frameExtraCounter = 0f;
                    _frameExtra++;
                    if (_frameExtra >= 24)
                    {
                        _frameExtra = 12;
                    }
                }
                break;
            }
            if (_frameExtra < 24)
            {
                _frameExtra = 24;
            }
            _frameExtraCounter += 1f;
            if (_frameExtraCounter >= 3f)
            {
                _frameExtraCounter = 0f;
                _frameExtra++;
                if (_frameExtra >= 27)
                {
                    _frameExtra = 24;
                }
            }
            break;
        case 8:
        {
            if (state != 0 && state != 1)
            {
                break;
            }
            Vector2 position = default(Vector2);
            position.X = mountedPlayer.position.X;
            position.Y = mountedPlayer.position.Y + (float)mountedPlayer.height;
            int num6 = (int)(position.X / 16f);
            _ = position.Y / 16f;
            float num7 = 0f;
            float num8 = mountedPlayer.width;
            while (num8 > 0f)
            {
                float num9 = (float)((num6 + 1) * 16) - position.X;
                if (num9 > num8)
                {
                    num9 = num8;
                }
                num7 += Collision.GetTileRotation(position) * num9;
                num8 -= num9;
                position.X += num9;
                num6++;
            }
            float num10 = num7 / (float)mountedPlayer.width - mountedPlayer.fullRotation;
            float num11 = 0f;
            float num12 = (float)Math.PI / 20f;
            if (num10 < 0f)
            {
                num11 = ((!(num10 > 0f - num12)) ? (0f - num12) : num10);
            }
            else if (num10 > 0f)
            {
                num11 = ((!(num10 < num12)) ? num12 : num10);
            }
            if (num11 != 0f)
            {
                mountedPlayer.fullRotation += num11;
                if (mountedPlayer.fullRotation > (float)Math.PI / 4f)
                {
                    mountedPlayer.fullRotation = (float)Math.PI / 4f;
                }
                if (mountedPlayer.fullRotation < -(float)Math.PI / 4f)
                {
                    mountedPlayer.fullRotation = -(float)Math.PI / 4f;
                }
            }
            break;
        }
        case 10:
        case 40:
        case 41:
        case 42:
        case 47:
        {
            bool flag5 = Math.Abs(velocity.X) > DashSpeed - RunSpeed / 2f;
            if (state == 1)
            {
                bool flag6 = false;
                if (flag5)
                {
                    state = 5;
                    if (_frameExtra < 6)
                    {
                        flag6 = true;
                    }
                    _frameExtra++;
                }
                else
                {
                    _frameExtra = 0;
                }
                if ((_type == 10 || _type == 47) && flag6)
                {
                    int type = 6;
                    if (_type == 10)
                    {
                        type = Utils.SelectRandom<int>(Main.rand, 176, 177, 179);
                    }
                    Vector2 vector8 = mountedPlayer.Center + new Vector2(mountedPlayer.width * mountedPlayer.direction, 0f);
                    Vector2 vector9 = new Vector2(40f, 30f);
                    float num22 = (float)Math.PI * 2f * Main.rand.NextFloat();
                    for (float num23 = 0f; num23 < 14f; num23 += 1f)
                    {
                        Dust dust5 = Main.dust[Dust.NewDust(vector8, 0, 0, type)];
                        Vector2 vector10 = Vector2.UnitY.RotatedBy(num23 * ((float)Math.PI * 2f) / 14f + num22);
                        vector10 *= 0.2f * (float)_frameExtra;
                        dust5.position = vector8 + vector10 * vector9;
                        dust5.velocity = vector10 + new Vector2(RunSpeed - (float)(Math.Sign(velocity.X) * _frameExtra * 2), 0f);
                        dust5.noGravity = true;
                        if (_type == 47)
                        {
                            dust5.noLightEmittence = true;
                        }
                        dust5.scale = 1f + Main.rand.NextFloat() * 0.8f;
                        dust5.fadeIn = Main.rand.NextFloat() * 2f;
                        dust5.shader = GameShaders.Armor.GetSecondaryShader(mountedPlayer.cMount, mountedPlayer);
                    }
                }
            }
            if (_type == 10 && flag5)
            {
                Dust obj3 = Main.dust[Dust.NewDust(mountedPlayer.position, mountedPlayer.width, mountedPlayer.height, Utils.SelectRandom<int>(Main.rand, 176, 177, 179))];
                obj3.velocity = Vector2.Zero;
                obj3.noGravity = true;
                obj3.scale = 0.5f + Main.rand.NextFloat() * 0.8f;
                obj3.fadeIn = 1f + Main.rand.NextFloat() * 2f;
                obj3.shader = GameShaders.Armor.GetSecondaryShader(mountedPlayer.cMount, mountedPlayer);
            }
            if (_type == 47 && flag5 && velocity.Y == 0f)
            {
                int num24 = (int)mountedPlayer.Center.X / 16;
                int num25 = (int)(mountedPlayer.position.Y + (float)mountedPlayer.height - 1f) / 16;
                Tile tile = Main.tile[num24, num25 + 1];
                if (tile != null && tile.active() && tile.liquid == 0 && WorldGen.SolidTileAllowBottomSlope(num24, num25 + 1))
                {
                    ParticleOrchestrator.RequestParticleSpawn(clientOnly: true, ParticleOrchestraType.WallOfFleshGoatMountFlames, new ParticleOrchestraSettings
                    {
                        PositionInWorld = new Vector2(num24 * 16 + 8, num25 * 16 + 16)
                    }, mountedPlayer.whoAmI);
                }
            }
            break;
        }
        case 44:
        {
            state = 1;
            bool flag3 = Math.Abs(velocity.X) > DashSpeed - RunSpeed / 4f;
            if (_mountSpecificData == null)
            {
                _mountSpecificData = false;
            }
            bool flag4 = (bool)_mountSpecificData;
            if (flag4 && !flag3)
            {
                _mountSpecificData = false;
            }
            else if (!flag4 && flag3)
            {
                _mountSpecificData = true;
                Vector2 vector5 = mountedPlayer.Center + new Vector2(mountedPlayer.width * mountedPlayer.direction, 0f);
                Vector2 vector6 = new Vector2(40f, 30f);
                float num17 = (float)Math.PI * 2f * Main.rand.NextFloat();
                for (float num18 = 0f; num18 < 20f; num18 += 1f)
                {
                    Dust dust4 = Main.dust[Dust.NewDust(vector5, 0, 0, 228)];
                    Vector2 vector7 = Vector2.UnitY.RotatedBy(num18 * ((float)Math.PI * 2f) / 20f + num17);
                    vector7 *= 0.8f;
                    dust4.position = vector5 + vector7 * vector6;
                    dust4.velocity = vector7 + new Vector2(RunSpeed - (float)Math.Sign(velocity.Length()), 0f);
                    if (velocity.X > 0f)
                    {
                        dust4.velocity.X *= -1f;
                    }
                    if (Main.rand.Next(2) == 0)
                    {
                        dust4.velocity *= 0.5f;
                    }
                    dust4.noGravity = true;
                    dust4.scale = 1.5f + Main.rand.NextFloat() * 0.8f;
                    dust4.fadeIn = 0f;
                    dust4.shader = GameShaders.Armor.GetSecondaryShader(mountedPlayer.cMount, mountedPlayer);
                }
            }
            int num19 = (int)RunSpeed - (int)Math.Abs(velocity.X);
            if (num19 <= 0)
            {
                num19 = 1;
            }
            if (Main.rand.Next(num19) == 0)
            {
                int num20 = 22;
                int num21 = mountedPlayer.width / 2 + 10;
                Vector2 bottom = mountedPlayer.Bottom;
                bottom.X -= num21;
                bottom.Y -= num20 - 6;
                Dust obj2 = Main.dust[Dust.NewDust(bottom, num21 * 2, num20, 228)];
                obj2.velocity = Vector2.Zero;
                obj2.noGravity = true;
                obj2.noLight = true;
                obj2.scale = 0.25f + Main.rand.NextFloat() * 0.8f;
                obj2.fadeIn = 0.5f + Main.rand.NextFloat() * 2f;
                obj2.shader = GameShaders.Armor.GetSecondaryShader(mountedPlayer.cMount, mountedPlayer);
            }
            break;
        }
        case 45:
        {
            bool flag = Math.Abs(velocity.X) > DashSpeed * 0.9f;
            if (_mountSpecificData == null)
            {
                _mountSpecificData = false;
            }
            bool flag2 = (bool)_mountSpecificData;
            if (flag2 && !flag)
            {
                _mountSpecificData = false;
            }
            else if (!flag2 && flag)
            {
                _mountSpecificData = true;
                Vector2 vector2 = mountedPlayer.Center + new Vector2(mountedPlayer.width * mountedPlayer.direction, 0f);
                Vector2 vector3 = new Vector2(40f, 30f);
                float num13 = (float)Math.PI * 2f * Main.rand.NextFloat();
                for (float num14 = 0f; num14 < 20f; num14 += 1f)
                {
                    Dust dust2 = Main.dust[Dust.NewDust(vector2, 0, 0, 6)];
                    Vector2 vector4 = Vector2.UnitY.RotatedBy(num14 * ((float)Math.PI * 2f) / 20f + num13);
                    vector4 *= 0.8f;
                    dust2.position = vector2 + vector4 * vector3;
                    dust2.velocity = vector4 + new Vector2(RunSpeed - (float)Math.Sign(velocity.Length()), 0f);
                    if (velocity.X > 0f)
                    {
                        dust2.velocity.X *= -1f;
                    }
                    if (Main.rand.Next(2) == 0)
                    {
                        dust2.velocity *= 0.5f;
                    }
                    dust2.noGravity = true;
                    dust2.scale = 1.5f + Main.rand.NextFloat() * 0.8f;
                    dust2.fadeIn = 0f;
                    dust2.shader = GameShaders.Armor.GetSecondaryShader(mountedPlayer.cMount, mountedPlayer);
                }
            }
            if (flag)
            {
                int num15 = Utils.SelectRandom(Main.rand, new short[3] { 6, 6, 31 });
                int num16 = 6;
                Dust dust3 = Main.dust[Dust.NewDust(mountedPlayer.Center - new Vector2(num16, num16 - 12), num16 * 2, num16 * 2, num15)];
                dust3.velocity = mountedPlayer.velocity * 0.1f;
                if (Main.rand.Next(2) == 0)
                {
                    dust3.noGravity = true;
                }
                dust3.scale = 0.7f + Main.rand.NextFloat() * 0.8f;
                if (Main.rand.Next(3) == 0)
                {
                    dust3.fadeIn = 0.1f;
                }
                if (num15 == 31)
                {
                    dust3.noGravity = true;
                    dust3.scale *= 1.5f;
                    dust3.fadeIn = 0.2f;
                }
                dust3.shader = GameShaders.Armor.GetSecondaryShader(mountedPlayer.cMount, mountedPlayer);
            }
            break;
        }
        case 48:
            state = 1;
            break;
        case 39:
            _frameExtraCounter += 1f;
            if (_frameExtraCounter > 6f)
            {
                _frameExtraCounter = 0f;
                _frameExtra++;
                if (_frameExtra > 5)
                {
                    _frameExtra = 0;
                }
            }
            break;
        case 50:
            if (mountedPlayer.velocity.Y == 0f)
            {
                _frameExtraCounter = 0f;
                _frameExtra = 3;
                break;
            }
            _frameExtraCounter += 1f;
            if (Flight())
            {
                _frameExtraCounter += 1f;
            }
            if (_frameExtraCounter > 7f)
            {
                _frameExtraCounter = 0f;
                _frameExtra++;
                if (_frameExtra > 3)
                {
                    _frameExtra = 0;
                }
            }
            break;
        case 14:
        {
            bool num = Math.Abs(velocity.X) > RunSpeed / 2f;
            float num2 = Math.Sign(mountedPlayer.velocity.X);
            float num3 = 12f;
            float num4 = 40f;
            if (!num)
            {
                mountedPlayer.basiliskCharge = 0f;
            }
            else
            {
                mountedPlayer.basiliskCharge = Utils.Clamp(mountedPlayer.basiliskCharge + 1f / 180f, 0f, 1f);
            }
            if ((double)mountedPlayer.position.Y > Main.worldSurface * 16.0 + 160.0)
            {
                Lighting.AddLight(mountedPlayer.Center, 0.5f, 0.1f, 0.1f);
            }
            if (num && velocity.Y == 0f)
            {
                for (int i = 0; i < 2; i++)
                {
                    Dust obj = Main.dust[Dust.NewDust(mountedPlayer.BottomLeft, mountedPlayer.width, 6, 31)];
                    obj.velocity = new Vector2(velocity.X * 0.15f, Main.rand.NextFloat() * -2f);
                    obj.noLight = true;
                    obj.scale = 0.5f + Main.rand.NextFloat() * 0.8f;
                    obj.fadeIn = 0.5f + Main.rand.NextFloat() * 1f;
                    obj.shader = GameShaders.Armor.GetSecondaryShader(mountedPlayer.cMount, mountedPlayer);
                }
                if (mountedPlayer.cMount == 0)
                {
                    mountedPlayer.position += new Vector2(num2 * 24f, 0f);
                    mountedPlayer.FloorVisuals(Falling: true);
                    mountedPlayer.position -= new Vector2(num2 * 24f, 0f);
                }
            }
            if (num2 != (float)mountedPlayer.direction)
            {
                break;
            }
            for (int j = 0; j < (int)(3f * mountedPlayer.basiliskCharge); j++)
            {
                Dust dust = Main.dust[Dust.NewDust(mountedPlayer.BottomLeft, mountedPlayer.width, 6, 6)];
                Vector2 vector = mountedPlayer.Center + new Vector2(num2 * num4, num3);
                dust.position = mountedPlayer.Center + new Vector2(num2 * (num4 - 2f), num3 - 6f + Main.rand.NextFloat() * 12f);
                dust.velocity = (dust.position - vector).SafeNormalize(Vector2.Zero) * (3.5f + Main.rand.NextFloat() * 0.5f);
                if (dust.velocity.Y < 0f)
                {
                    dust.velocity.Y *= 1f + 2f * Main.rand.NextFloat();
                }
                dust.velocity += mountedPlayer.velocity * 0.55f;
                dust.velocity *= mountedPlayer.velocity.Length() / RunSpeed;
                dust.velocity *= mountedPlayer.basiliskCharge;
                dust.noGravity = true;
                dust.noLight = true;
                dust.scale = 0.5f + Main.rand.NextFloat() * 0.8f;
                dust.fadeIn = 0.5f + Main.rand.NextFloat() * 1f;
                dust.shader = GameShaders.Armor.GetSecondaryShader(mountedPlayer.cMount, mountedPlayer);
            }
            break;
        }
        }
        switch (state)
        {
        case 0:
            if (_data.idleFrameCount != 0)
            {
                if (_type == 5)
                {
                    if (_fatigue != 0f)
                    {
                        if (_idleTime == 0)
                        {
                            _idleTimeNext = _idleTime + 1;
                        }
                    }
                    else
                    {
                        _idleTime = 0;
                        _idleTimeNext = 2;
                    }
                }
                else if (_idleTime == 0)
                {
                    _idleTimeNext = Main.rand.Next(900, 1500);
                    if (_type == 17)
                    {
                        _idleTimeNext = Main.rand.Next(120, 300);
                    }
                }
                _idleTime++;
            }
            _frameCounter += 1f;
            if (_data.idleFrameCount != 0 && _idleTime >= _idleTimeNext)
            {
                float num29 = _data.idleFrameDelay;
                if (_type == 5)
                {
                    num29 *= 2f - 1f * _fatigue / _fatigueMax;
                }
                int num30 = (int)((float)(_idleTime - _idleTimeNext) / num29);
                int idleFrameCount = _data.idleFrameCount;
                if (num30 >= idleFrameCount)
                {
                    if (_data.idleFrameLoop)
                    {
                        _idleTime = _idleTimeNext;
                        _frame = _data.idleFrameStart;
                    }
                    else
                    {
                        _frameCounter = 0f;
                        _frame = _data.standingFrameStart;
                        _idleTime = 0;
                    }
                }
                else
                {
                    _frame = _data.idleFrameStart + num30;
                    if (_data.idleFrameLoop)
                    {
                        if (_frame < _data.idleFrameStart || _frame >= _data.idleFrameStart + _data.idleFrameCount)
                        {
                            _frame = _data.idleFrameStart;
                        }
                    }
                    else if (_frame < _data.standingFrameStart || _frame >= _data.standingFrameStart + _data.standingFrameCount)
                    {
                        _frame = _data.standingFrameStart;
                    }
                }
                if (_type == 5)
                {
                    _frameExtra = _frame;
                }
                if (_type == 17)
                {
                    _frameExtra = _frame;
                    _frame = 0;
                }
            }
            else
            {
                if (_frameCounter > (float)_data.standingFrameDelay)
                {
                    _frameCounter -= _data.standingFrameDelay;
                    _frame++;
                }
                if (_frame < _data.standingFrameStart || _frame >= _data.standingFrameStart + _data.standingFrameCount)
                {
                    _frame = _data.standingFrameStart;
                }
            }
            break;
        case 1:
        {
            float num26;
            switch (_type)
            {
            case 9:
            case 46:
                num26 = ((!_flipDraw) ? Math.Abs(velocity.X) : (0f - Math.Abs(velocity.X)));
                break;
            case 44:
                num26 = Math.Max(1f, Math.Abs(velocity.X) * 0.25f);
                break;
            case 48:
                num26 = Math.Max(0.5f, velocity.Length() * 0.125f);
                break;
            case 6:
                num26 = (_flipDraw ? velocity.X : (0f - velocity.X));
                break;
            case 13:
                num26 = (_flipDraw ? velocity.X : (0f - velocity.X));
                break;
            case 50:
                num26 = Math.Abs(velocity.X) * 0.5f;
                break;
            default:
                num26 = Math.Abs(velocity.X);
                break;
            }
            _frameCounter += num26;
            if (num26 >= 0f)
            {
                if (_frameCounter > (float)_data.runningFrameDelay)
                {
                    _frameCounter -= _data.runningFrameDelay;
                    _frame++;
                }
                if (_frame < _data.runningFrameStart || _frame >= _data.runningFrameStart + _data.runningFrameCount)
                {
                    _frame = _data.runningFrameStart;
                }
            }
            else
            {
                if (_frameCounter < 0f)
                {
                    _frameCounter += _data.runningFrameDelay;
                    _frame--;
                }
                if (_frame < _data.runningFrameStart || _frame >= _data.runningFrameStart + _data.runningFrameCount)
                {
                    _frame = _data.runningFrameStart + _data.runningFrameCount - 1;
                }
            }
            break;
        }
        case 3:
            _frameCounter += 1f;
            if (_frameCounter > (float)_data.flyingFrameDelay)
            {
                _frameCounter -= _data.flyingFrameDelay;
                _frame++;
            }
            if (_frame < _data.flyingFrameStart || _frame >= _data.flyingFrameStart + _data.flyingFrameCount)
            {
                _frame = _data.flyingFrameStart;
            }
            break;
        case 2:
            _frameCounter += 1f;
            if (_frameCounter > (float)_data.inAirFrameDelay)
            {
                _frameCounter -= _data.inAirFrameDelay;
                _frame++;
            }
            if (_frame < _data.inAirFrameStart || _frame >= _data.inAirFrameStart + _data.inAirFrameCount)
            {
                _frame = _data.inAirFrameStart;
            }
            if (_type == 4)
            {
                if (velocity.Y < 0f)
                {
                    _frame = 3;
                }
                else
                {
                    _frame = 6;
                }
            }
            else if (_type == 52)
            {
                if (velocity.Y < 0f)
                {
                    _frame = _data.inAirFrameStart;
                }
                if (_frame == _data.inAirFrameStart + _data.inAirFrameCount - 1)
                {
                    _frameCounter = 0f;
                }
            }
            else if (_type == 5)
            {
                float num27 = _fatigue / _fatigueMax;
                _frameExtraCounter += 6f - 4f * num27;
                if (_frameExtraCounter > (float)_data.flyingFrameDelay)
                {
                    _frameExtra++;
                    _frameExtraCounter -= _data.flyingFrameDelay;
                }
                if (_frameExtra < _data.flyingFrameStart || _frameExtra >= _data.flyingFrameStart + _data.flyingFrameCount)
                {
                    _frameExtra = _data.flyingFrameStart;
                }
            }
            else if (_type == 23)
            {
                float num28 = mountedPlayer.velocity.Length();
                if (num28 < 1f)
                {
                    _frame = 0;
                    _frameCounter = 0f;
                }
                else if (num28 > 5f)
                {
                    _frameCounter += 1f;
                }
            }
            break;
        case 4:
        {
            int num31 = (int)((Math.Abs(velocity.X) + Math.Abs(velocity.Y)) / 2f);
            _frameCounter += num31;
            if (_frameCounter > (float)_data.swimFrameDelay)
            {
                _frameCounter -= _data.swimFrameDelay;
                _frame++;
            }
            if (_frame < _data.swimFrameStart || _frame >= _data.swimFrameStart + _data.swimFrameCount)
            {
                _frame = _data.swimFrameStart;
            }
            if (Type == 37 && velocity.X == 0f)
            {
                _frame = 4;
            }
            break;
        }
        case 5:
        {
            float num26 = _type switch
            {
                9 => (!_flipDraw) ? Math.Abs(velocity.X) : (0f - Math.Abs(velocity.X)), 
                6 => _flipDraw ? velocity.X : (0f - velocity.X), 
                13 => _flipDraw ? velocity.X : (0f - velocity.X), 
                _ => Math.Abs(velocity.X), 
            };
            _frameCounter += num26;
            if (num26 >= 0f)
            {
                if (_frameCounter > (float)_data.dashingFrameDelay)
                {
                    _frameCounter -= _data.dashingFrameDelay;
                    _frame++;
                }
                if (_frame < _data.dashingFrameStart || _frame >= _data.dashingFrameStart + _data.dashingFrameCount)
                {
                    _frame = _data.dashingFrameStart;
                }
            }
            else
            {
                if (_frameCounter < 0f)
                {
                    _frameCounter += _data.dashingFrameDelay;
                    _frame--;
                }
                if (_frame < _data.dashingFrameStart || _frame >= _data.dashingFrameStart + _data.dashingFrameCount)
                {
                    _frame = _data.dashingFrameStart + _data.dashingFrameCount - 1;
                }
            }
            break;
        }
        }
    }

References Terraria.Mount._aiming, Terraria.Mount._data, Terraria.Mount._fatigue, Terraria.Mount._fatigueMax, Terraria.Mount._flipDraw, Terraria.Mount._frame, Terraria.Mount._frameCounter, Terraria.Mount._frameExtra, Terraria.Mount._frameExtraCounter, Terraria.Mount._frameState, Terraria.Mount._idleTime, Terraria.Mount._idleTimeNext, Terraria.Mount._mountSpecificData, Terraria.Mount._type, System.Math.Abs(), Terraria.Tile.active(), Terraria.Lighting.AddLight(), Terraria.Graphics.Shaders.GameShaders.Armor, Terraria.Mount.MountData.dashingFrameCount, Terraria.Mount.MountData.dashingFrameDelay, Terraria.Mount.MountData.dashingFrameStart, Terraria.Mount.DashSpeed, Terraria.Main.dust, Terraria.Mount.MountData.emitsLight, Terraria.Mount.Flight(), Terraria.Mount.MountData.flyingFrameCount, Terraria.Mount.MountData.flyingFrameDelay, Terraria.Mount.MountData.flyingFrameStart, Terraria.Utils.GetLerpValue(), Terraria.Collision.GetTileRotation(), Terraria.Mount.MountData.idleFrameCount, Terraria.Mount.MountData.idleFrameDelay, Terraria.Mount.MountData.idleFrameLoop, Terraria.Mount.MountData.idleFrameStart, Terraria.Mount.MountData.inAirFrameCount, Terraria.Mount.MountData.inAirFrameDelay, Terraria.Mount.MountData.inAirFrameStart, Microsoft.Xna.Framework.Vector2.Length(), Terraria.Mount.MountData.lightColor, System.Math.Max(), Terraria.Dust.NewDust(), System.obj, System.Math.PI, Terraria.Main.rand, Terraria.GameContent.Drawing.ParticleOrchestrator.RequestParticleSpawn(), Terraria.Mount.MountData.runningFrameCount, Terraria.Mount.MountData.runningFrameDelay, Terraria.Mount.MountData.runningFrameStart, Terraria.Mount.RunSpeed, System.Math.Sign(), Terraria.WorldGen.SolidTileAllowBottomSlope(), Terraria.Mount.MountData.standingFrameCount, Terraria.Mount.MountData.standingFrameDelay, Terraria.Mount.MountData.standingFrameStart, System.state, Terraria.Mount.MountData.swimFrameCount, Terraria.Mount.MountData.swimFrameDelay, Terraria.Mount.MountData.swimFrameStart, Terraria.Main.tile, System.type, Microsoft.Xna.Framework.Vector2.UnitY, Terraria.Mount.UpdateFrame_GolfCart(), Microsoft.Xna.Framework.Graphics.Vector2, Terraria.Dust.velocity, Terraria.Main.worldSurface, Microsoft.Xna.Framework.Point.X, Microsoft.Xna.Framework.Vector2.X, Microsoft.Xna.Framework.Vector3.X, Microsoft.Xna.Framework.Point.Y, Microsoft.Xna.Framework.Vector2.Y, Microsoft.Xna.Framework.Vector3.Y, Microsoft.Xna.Framework.Vector3.Z, and Microsoft.Xna.Framework.Vector2.Zero.

Referenced by Terraria.Mount.TryLanding().